ExeName -> TargetName for link rule

doc/rules.md

@@ -102,10 +102,10 @@ Generates an executable or shared object / dynamic library.
 ### D
 
 ```d
-Target link(ExeName exeName, alias dependenciesFunc, Flags flags = Flags())
+Target link(TargetName targetName, alias dependenciesFunc, Flags flags = Flags())
 ```
 
-* `exeName`: The name of the executable.
+* `targetName`: The name of the executable.
 * `dependenciesFunc`: A function that, at runtime, returns an array of `Target` structs to link to
 * `flags`: Linker flags.
 
@@ -210,15 +210,15 @@ The binary is compiled as one translation unit by compiling a C/C++ file that
 ### D
 
 ```d
-Target unityBuild(ExeName exeName,
+Target unityBuild(TargetName targetName,
                   alias sourcesFunc,
                   Flags flags = Flags(),
                   IncludePaths includes = IncludePaths(),
                   alias dependenciesFunc = emptyTargets,
                   alias implicitsFunc = emptyTargets)();
 ```
 
-* `exeName`: Same as in `scriptlike`
+* `targetName`: Same as in `scriptlike`
 * `sourcesFunc`: Same as in `objectFiles`.
 * `flags`: Compiler flags.
 * `includes`: Include paths.

payload/reggae/rules/c_and_cpp.d

@@ -11,7 +11,7 @@ import std.file;
 
 @safe:
 
-Target unityBuild(ExeName exeName,
+Target unityBuild(TargetName targetName,
                   alias sourcesFunc,
                   CompilerFlags flags = CompilerFlags(),
                   IncludePaths includes = IncludePaths(),
@@ -22,7 +22,7 @@ Target unityBuild(ExeName exeName,
 
     const srcFiles = sourcesToFileNames!sourcesFunc(options);
 
-    immutable dirName = buildPath(options.workingDir, objDirOf(Target(exeName.value)));
+    immutable dirName = buildPath(options.workingDir, objDirOf(Target(targetName.value)));
     dirName.exists || mkdirRecurse(dirName);
 
     immutable fileName = buildPath(dirName, "unity.cpp");
@@ -32,7 +32,7 @@ Target unityBuild(ExeName exeName,
 
     return unityTarget(
         options,
-        exeName,
+        targetName,
         options.projectPath,
         srcFiles,
         flags,
@@ -70,7 +70,7 @@ string unityFileContents(in string projectPath, in string[] files) pure {
 /**
  Returns the unity build target for these parameters.
  */
-Target unityTarget(ExeName exeName,
+Target unityTarget(TargetName targetName,
                    string projectPath,
                    string[] srcFiles,
                    CompilerFlags flags = CompilerFlags(),
@@ -79,11 +79,11 @@ Target unityTarget(ExeName exeName,
                    alias implicitsFunc = emptyTargets,
     )() {
     import reggae.config: options;
-    return unityTarget(options, exeName, projectPath, srcFiles, flags, includes, dependenciesFunc());
+    return unityTarget(options, targetName, projectPath, srcFiles, flags, includes, dependenciesFunc());
 }
 
 private Target unityTarget(R1, R2)(in imported!"reggae.options".Options options,
-                                   in ExeName exeName,
+                                   in TargetName targetName,
                                    in string projectPath,
                                    in string[] srcFiles,
                                    in CompilerFlags flags = CompilerFlags(),
@@ -98,10 +98,10 @@ private Target unityTarget(R1, R2)(in imported!"reggae.options".Options options,
     import std.algorithm;
 
     auto justFileName = srcFiles.map!getLanguage.front == Language.C ? "unity.c" : "unity.cpp";
-    auto unityFileName = buildPath(gBuilddir, objDirOf(Target(exeName.value)), justFileName);
+    auto unityFileName = buildPath(gBuilddir, objDirOf(Target(targetName.value)), justFileName);
     auto unityFileTarget = Target.phony(unityFileName, "", [], srcFiles.map!(a => Target(a)).array);
     auto incompleteTarget = Target(
-        exeName.value,
+        targetName.value,
         "", // filled in below by compileTarget
         unityFileTarget ~ dependencies.array,
     );

payload/reggae/rules/cmake.d

@@ -241,7 +241,7 @@ private imported!"reggae.build".Target toReggaeTarget(in imported!"std.json".JSO
     import reggae.config: options;
     import reggae.rules.common : objectFile, link, staticLibraryTarget;
     import reggae.build : Target;
-    import reggae.types : SourceFile, ExeName, LinkerFlags;
+    import reggae.types : SourceFile, TargetName, LinkerFlags;
     import std.format : format;
     import std.exception : enforce;
     import std.path : buildNormalizedPath, isAbsolute, baseName, extension;
@@ -313,7 +313,7 @@ private imported!"reggae.build".Target toReggaeTarget(in imported!"std.json".JSO
                 enum sharedLibFlag = "-shared";
             }
             return link(
-                ExeName(reggaeArtifactPath),
+                TargetName(reggaeArtifactPath),
                 intermediateTargets,
                 LinkerFlags(sharedLibFlag ~ linkAndLibrarySearchPathFlags),
                 implicits,
@@ -322,7 +322,7 @@ private imported!"reggae.build".Target toReggaeTarget(in imported!"std.json".JSO
 
         case Executable:
             return link(
-                ExeName(reggaeArtifactPath),
+                TargetName(reggaeArtifactPath),
                 intermediateTargets,
                 LinkerFlags(linkAndLibrarySearchPathFlags),
                 implicits,

payload/reggae/rules/common.d

@@ -159,9 +159,11 @@ Target executable(ExeName exeName,
                   ImportPaths includes = ImportPaths(),
                   StringImportPaths stringImports = StringImportPaths(),
                   LinkerFlags linkerFlags = LinkerFlags())
-    () {
+    ()
+{
+    import reggae.types: TargetName;
     auto objs = objectFiles!(sourcesFunc, compilerFlags, includes, stringImports);
-    return link!(exeName, { return objs; }, linkerFlags);
+    return link!(TargetName(exeName.value), { return objs; }, linkerFlags);
 }
 
 Target executable(in imported!"reggae.options".Options options,
@@ -188,7 +190,7 @@ Target executable(in imported!"reggae.options".Options options,
         includes,
         stringImports
     );
-    return link(ExeName(name), objs, const LinkerFlags(linkerFlags));
+    return link(TargetName(name), objs, const LinkerFlags(linkerFlags));
 }
 
 
@@ -202,9 +204,9 @@ Target executable(in imported!"reggae.options".Options options,
  If any D files are found, the linker is the D compiler, and so on with
  C++ and C. If none of those apply, the D compiler is used.
  */
-Target link(ExeName exeName, alias dependenciesFunc, LinkerFlags flags = LinkerFlags())() {
+Target link(TargetName targetName, alias dependenciesFunc, LinkerFlags flags = LinkerFlags())() {
     auto dependencies = dependenciesFunc();
-    return link(exeName, dependencies, flags);
+    return link(targetName, dependencies, flags);
 }
 
 /**
@@ -214,22 +216,31 @@ Target link(ExeName exeName, alias dependenciesFunc, LinkerFlags flags = LinkerF
  If any D files are found, the linker is the D compiler, and so on with
  C++ and C. If none of those apply, the D compiler is used.
  */
-Target link(in ExeName exeName, Target[] dependencies, in LinkerFlags flags = LinkerFlags(),
-            in LibraryFlags linkLibraryFlags = LibraryFlags()) @safe pure {
+Target link(in TargetName targetName,
+            Target[] dependencies,
+            in LinkerFlags flags = LinkerFlags(),
+            in LibraryFlags linkLibraryFlags = LibraryFlags())
+    @safe pure
+{
     auto command = Command(
         CommandType.link,
         assocList([assocEntry("flags", flags.value.dup), assocEntry("link_libraries", linkLibraryFlags.value.dup)]),
     );
-    return Target(exeName.value, command, dependencies);
+    return Target(targetName.value, command, dependencies);
 }
 
-Target link(const ExeName exeName, Target[] dependencies, in LinkerFlags flags, Target[] implicits,
-            in LibraryFlags linkLibraryFlags = LibraryFlags()) @safe pure {
+Target link(const TargetName targetName,
+            Target[] dependencies,
+            in LinkerFlags flags,
+            Target[] implicits,
+            in LibraryFlags linkLibraryFlags = LibraryFlags())
+    @safe pure
+{
     auto command = Command(
         CommandType.link,
         assocList([assocEntry("flags", flags.value.dup), assocEntry("link_libraries", linkLibraryFlags.value.dup)]),
     );
-    return Target(exeName.value, command, dependencies, implicits);
+    return Target(targetName.value, command, dependencies, implicits);
 }
 
 /**

payload/reggae/rules/d.d

@@ -363,7 +363,7 @@ Target scriptlike(
         stringImportPaths,
     );
 
-    return link(ExeName(app.exeFileName.value), dependencies ~ linkWith);
+    return link(TargetName(app.exeFileName.value), dependencies ~ linkWith);
 }
 
 
@@ -397,12 +397,12 @@ private auto runDCompiler(in imported!"reggae.options".Options options,
     return depsFile;
 }
 
-Target dlink(in ExeName exeName, Target[] dependencies, in LinkerFlags flags = LinkerFlags()) @safe pure {
+Target dlink(in TargetName targetName, Target[] dependencies, in LinkerFlags flags = LinkerFlags()) @safe pure {
     import reggae.rules.common: link;
     return link(
-        exeName,
+        targetName,
         dependencies,
-        LinkerFlags(flags.value ~ maybeLibFlags(exeName.value))
+        LinkerFlags(flags.value ~ maybeLibFlags(targetName.value))
     );
 }
 

payload/reggae/rules/dub/compile.d

@@ -72,10 +72,10 @@ static if(imported!"reggae.config".isDubProject) {
     {
         import reggae.config: configToDubInfo;
         import reggae.rules.common: link;
-        import reggae.types: ExeName, LinkerFlags;
+        import reggae.types: LinkerFlags;
 
         return link!(
-            ExeName(targetName.value),
+            targetName,
             objsFunction,
             LinkerFlags(linkerFlags.value ~ configToDubInfo[config.value].linkerFlags)
         );

payload/reggae/rules/dub/external.d

@@ -53,7 +53,7 @@ imported!"reggae.build".Target dubDependant(
     import reggae.rules.dub: oneOptionalOf, isOfType;
     import reggae.rules.d: dlink;
     import reggae.rules.common: objectFiles;
-    import reggae.types: ExeName, CompilerFlags, LinkerFlags, ImportPaths, StringImportPaths;
+    import reggae.types: TargetName, CompilerFlags, LinkerFlags, ImportPaths, StringImportPaths;
     import reggae.config: reggaeOptions = options; // the ones used to run reggae
     import std.meta: Filter;
     import std.algorithm: map, joiner;
@@ -98,8 +98,7 @@ imported!"reggae.build".Target dubDependant(
 
     const targetNameWithExt = withExtension(targetName, targetType);
     return dlink(
-         // FIXME: ExeName doesn't make sense for libraries, conversion TargetName -> ExeName is silly
-        ExeName(targetNameWithExt),
+        TargetName(targetNameWithExt),
         objs ~ dubDepsObjs,
         linkerFlags,
     );

payload/reggae/rules/dub/runtime.d

@@ -99,7 +99,7 @@ private imported!"reggae.build".Target objectsToTarget(
     import reggae.rules.d: dlink;
     import reggae.rules.common: link, libExt, dynExt;
     import reggae.dub.info: TargetType;
-    import reggae.types: ExeName, LinkerFlags;
+    import reggae.types: TargetName, LinkerFlags;
     import std.path: extension;
 
     if(dubInfo.targetType == TargetType.none)
@@ -116,7 +116,7 @@ private imported!"reggae.build".Target objectsToTarget(
         assert(name.extension == dynExt,
                "`" ~ name ~ "` does not have a dynamic library extension`");
 
-    return dlink(ExeName(name), allObjs, LinkerFlags(dubInfo.linkerFlags));
+    return dlink(TargetName(name), allObjs, LinkerFlags(dubInfo.linkerFlags));
 }
 
 private auto dubObjsDir(

tests/it/runtime/dub/proper.d

@@ -483,7 +483,7 @@ unittest {
                       import reggae;
                       alias lib = dubBuild!(Configuration("library"));
                       enum mainObj = objectFile!(SourceFile("source/main.d"));
-                      alias exe = link!(ExeName("d++"), targetConcat!(lib, mainObj));
+                      alias exe = link!(TargetName("d++"), targetConcat!(lib, mainObj));
                       mixin build!(exe);
                   });
 
@@ -522,7 +522,7 @@ unittest {
                       import reggae;
                       alias lib = dubBuild!(Configuration("library"));
                       enum mainObj = objectFile!(SourceFile("source/main.d"));
-                      alias exe = link!(ExeName("d++"), targetConcat!(lib, mainObj));
+                      alias exe = link!(TargetName("d++"), targetConcat!(lib, mainObj));
                       mixin build!(exe);
                   });
 

tests/it/runtime/issues.d

@@ -290,7 +290,7 @@ unittest {
                     CompilerFlags("-g"),
                     ImportPaths(["src"]),
                 );
-                alias app = link!(ExeName("app"), testObjs);
+                alias app = link!(TargetName("app"), testObjs);
                 mixin build!app;
             }
         );

tests/projects/d_cmake_shared/reggaefile.d

@@ -14,7 +14,7 @@ Build reggaeBuild() {
         enum flags = LinkerFlags(`-L-L.reggae -L-rpath="\$ORIGIN/.reggae" -L-lCalculatorShared`);
     }
 
-    auto dlangExeTarget = link(ExeName("dcpp"), dlangObjects!(Sources!"source"),
+    auto dlangExeTarget = link(TargetName("dcpp"), dlangObjects!(Sources!"source"),
                                flags, cmakeTargets);
 
     return Build(dlangExeTarget);

tests/projects/d_cmake_static/reggaefile.d

@@ -14,7 +14,7 @@ Build reggaeBuild() {
         enum flags = LinkerFlags(`-L-L.reggae -L-lCalculatorStatic`);
     }
 
-    auto dlangExeTarget = link(ExeName("dcpp"), dlangObjects!(Sources!"source"),
+    auto dlangExeTarget = link(TargetName("dcpp"), dlangObjects!(Sources!"source"),
                                flags, cmakeTargets);
 
     return Build(dlangExeTarget);

tests/projects/static_lib/reggaefile.d

@@ -4,5 +4,5 @@ import reggae;
 
 alias lib = staticLibrary!(`maths` ~ libExt, Sources!([`libsrc`]));
 enum mainObj = objectFile!(SourceFile(`src/main.d`), CompilerFlags(), ImportPaths(["libsrc"]));
-alias app = link!(ExeName("app"), targetConcat!(mainObj, lib), LinkerFlags());
+alias app = link!(TargetName("app"), targetConcat!(mainObj, lib), LinkerFlags());
 mixin build!app;

tests/projects/template_rules/reggaefile.d

@@ -2,5 +2,5 @@ module template_rules.reggaefile;
 
 import reggae;
 alias objs = objectFiles!(Sources!(), CompilerFlags(`-g -O0`));
-alias app = link!(ExeName(`app`), objs);
+alias app = link!(TargetName(`app`), objs);
 mixin build!app;

tests/projects/unity/reggaefile.d

@@ -1,7 +1,7 @@
 module unity.reggaefile;
 
 import reggae;
-alias app = unityBuild!(ExeName(`unity`),
+alias app = unityBuild!(TargetName(`unity`),
                         Sources!([`src`]),
                         CompilerFlags(`-g`));
 mixin build!app;

tests/ut/build.d

@@ -246,7 +246,7 @@ import std.format;
 
 @("Build with one dep in $builddir") unittest {
     auto target = Target("output", "cmd -o $out -c $in", Target("$builddir/input.d"));
-    alias top = link!(ExeName("ut"), targetConcat!(target));
+    alias top = link!(TargetName("ut"), targetConcat!(target));
     auto build = Build(top);
     build.targets[0].dependencyTargets[0].dependenciesInProjectPath("/path/to").shouldEqual(["input.d"]);
 }

tests/ut/cpprules.d

@@ -134,7 +134,7 @@ private void shouldEqualLines(string actual, string[] expected,
     }
 
     immutable projectPath = "/path/to/proj";
-    auto target = unityTarget!(ExeName("leapp"),
+    auto target = unityTarget!(TargetName("leapp"),
                                 projectPath,
                                 files,
                                 CompilerFlags("-g -O0"),
@@ -167,7 +167,7 @@ private void shouldEqualLines(string actual, string[] expected,
     }
 
     immutable projectPath = "/path/to/proj";
-    auto target = unityTarget!(ExeName("leapp"),
+    auto target = unityTarget!(TargetName("leapp"),
                                 projectPath,
                                 files,
                                 CompilerFlags("-g -O0"),

tests/ut/json_build/rules.d

@@ -64,7 +64,7 @@ string linkJsonString() @safe pure nothrow {
     import reggae.config: options;
     auto mainObj = Target("main.o", "dmd -I$project/src -c $in -of$out", Target("src/main.d"));
     auto mathsObj = Target("maths.o", "dmd -c $in -of$out", Target("src/maths.d"));
-    auto app = link(ExeName("myapp"), [mainObj, mathsObj], LinkerFlags("-L-M"));
+    auto app = link(TargetName("myapp"), [mainObj, mathsObj], LinkerFlags("-L-M"));
 
     jsonToBuild(options, "", linkJsonString).shouldEqual(Build(app));
 }
@@ -191,6 +191,6 @@ string targetConcatFixedJsonStr() @safe pure nothrow {
     import reggae.config: options;
     auto mainObj = Target("main.o", "dmd -I$project/src -c $in -of$out", Target("src/main.d"));
     auto mathsObj = Target("maths.o", "dmd -c $in -of$out", Target("src/maths.d"));
-    auto app = link(ExeName("myapp"), [mainObj, mathsObj], LinkerFlags("-L-M"));
+    auto app = link(TargetName("myapp"), [mainObj, mathsObj], LinkerFlags("-L-M"));
     jsonToBuild(options, "", targetConcatFixedJsonStr).shouldEqual(Build(app));
 }