Merge pull request #311 from atilaneves/delete-flags-type

"Type-safer" API

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/dub/info.d

@@ -170,6 +170,7 @@ struct DubInfo {
         @safe pure const
     {
         import reggae.path: deabsolutePath;
+        import reggae.types;
         import std.range: chain, only;
         import std.algorithm: filter, map;
         import std.array: array, replace;
@@ -221,8 +222,24 @@ struct DubInfo {
                 !options.dubDepObjsInsteadOfStaticLib;
 
             return isStaticLibDep
-                ? dlangStaticLibraryTogether(options, srcFiles, allCompilerFlags, importPaths, stringImportPaths, [], projDir)
-                : compileFunc()(options, srcFiles, allCompilerFlags, importPaths, stringImportPaths, [], projDir);
+                ? dlangStaticLibraryTogether(
+                    options,
+                    srcFiles,
+                    const CompilerFlags(allCompilerFlags),
+                    const ImportPaths(importPaths),
+                    const StringImportPaths(stringImportPaths),
+                    [],
+                    projDir
+                )
+                : compileFunc()(
+                    options,
+                    srcFiles,
+                    const CompilerFlags(allCompilerFlags),
+                    const ImportPaths(importPaths),
+                    const StringImportPaths(stringImportPaths),
+                    [],
+                    projDir
+                );
         }();
 
         const dubPkgRoot = buildPath(dubPackage.path).deabsolutePath.stripRight(dirSeparator);

payload/reggae/rules/c_and_cpp.d

@@ -11,9 +11,9 @@ import std.file;
 
 @safe:
 
-Target unityBuild(ExeName exeName,
+Target unityBuild(TargetName targetName,
                   alias sourcesFunc,
-                  Flags flags = Flags(),
+                  CompilerFlags flags = CompilerFlags(),
                   IncludePaths includes = IncludePaths(),
                   alias dependenciesFunc = emptyTargets,
                   alias implicitsFunc = emptyTargets)() @trusted {
@@ -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,23 +70,23 @@ 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,
-                   Flags flags = Flags(),
+                   CompilerFlags flags = CompilerFlags(),
                    IncludePaths includes = IncludePaths(),
                    alias dependenciesFunc = emptyTargets,
                    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 Flags flags = Flags(),
+                                   in CompilerFlags flags = CompilerFlags(),
                                    in IncludePaths includes = IncludePaths(),
                                    R1 dependencies = emptyTargets(),
                                    R2 implicits = emptyTargets(),
@@ -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,
     );
@@ -110,9 +110,9 @@ private Target unityTarget(R1, R2)(in imported!"reggae.options".Options options,
         options,
         incompleteTarget,
         unityFileName,
-        flags.value,
-        includes.value,
-        [],
+        flags,
+        includes,
+        StringImportPaths(),
         projectPath,
         No.justCompile,
     );

payload/reggae/rules/cmake.d

@@ -92,8 +92,8 @@ private bool isSupportedLanguage(in string lang) {
 }
 
 private struct CompileOptions {
-    import reggae.types : Flags, IncludePaths;
-    Flags compilerFlags;
+    import reggae.types : CompilerFlags, IncludePaths;
+    CompilerFlags compilerFlags;
     IncludePaths includes;
     SourceLanguage language;
 }
@@ -117,7 +117,7 @@ private CompileOptions getCompileOptions(in imported!"std.json".JSONValue target
     }
 
     static CompileOptions getCompileOptionsImpl(in imported!"std.json".JSONValue compileGroup, size_t groupIndex) {
-        import reggae.types : IncludePaths, Flags;
+        import reggae.types : IncludePaths, CompilerFlags;
 
         static CompileOptions[size_t] groupIndexToOptions;
 
@@ -151,7 +151,7 @@ private CompileOptions getCompileOptions(in imported!"std.json".JSONValue target
                                     .map!(incl => incl["path"].str)
                                     .array.IncludePaths;
         }
-        return groupIndexToOptions[groupIndex] = CompileOptions(Flags(defines ~ " " ~ compileCommand),
+        return groupIndexToOptions[groupIndex] = CompileOptions(CompilerFlags(defines ~ " " ~ compileCommand),
                                                                 includes,
                                                                 cast(SourceLanguage) compileGroup["language"].str);
     }
@@ -174,14 +174,14 @@ private bool isHeaderFile(in string file) {
 }
 
 private struct CMakeLinkerFlags {
-    import reggae.types : Flags, LibraryFlags;
-    Flags flags;
+    import reggae.types : LinkerFlags, LibraryFlags, LibraryPathFlags;
+    LinkerFlags flags;
     LibraryFlags libraryFlags;
-    Flags libraryPathFlags;
+    LibraryPathFlags libraryPathFlags;
 }
 
 private CMakeLinkerFlags getLinkerFlags(in imported!"std.json".JSONValue target, ref CMakeInfo cmakeInfo) {
-    import reggae.types : Flags, LibraryFlags;
+    import reggae.types : LinkerFlags, LibraryFlags, LibraryPathFlags;
     import std.array : join;
     import std.algorithm : each;
 
@@ -221,7 +221,7 @@ private CMakeLinkerFlags getLinkerFlags(in imported!"std.json".JSONValue target,
         }
     });
 
-    return CMakeLinkerFlags(Flags(flags), LibraryFlags(libraries), Flags(libraryPath));
+    return CMakeLinkerFlags(LinkerFlags(flags), LibraryFlags(libraries), LibraryPathFlags(libraryPath));
 }
 
 private enum TargetType : string {
@@ -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, Flags;
+    import reggae.types : SourceFile, TargetName, LinkerFlags;
     import std.format : format;
     import std.exception : enforce;
     import std.path : buildNormalizedPath, isAbsolute, baseName, extension;
@@ -312,12 +312,22 @@ private imported!"reggae.build".Target toReggaeTarget(in imported!"std.json".JSO
             } else {
                 enum sharedLibFlag = "-shared";
             }
-            return link(ExeName(reggaeArtifactPath), intermediateTargets, Flags(sharedLibFlag ~ linkAndLibrarySearchPathFlags),
-                        implicits, cmakeLinkerFlags.libraryFlags);
+            return link(
+                TargetName(reggaeArtifactPath),
+                intermediateTargets,
+                LinkerFlags(sharedLibFlag ~ linkAndLibrarySearchPathFlags),
+                implicits,
+                cmakeLinkerFlags.libraryFlags
+            );
 
         case Executable:
-            return link(ExeName(reggaeArtifactPath), intermediateTargets, Flags(linkAndLibrarySearchPathFlags),
-                        implicits, cmakeLinkerFlags.libraryFlags);
+            return link(
+                TargetName(reggaeArtifactPath),
+                intermediateTargets,
+                LinkerFlags(linkAndLibrarySearchPathFlags),
+                implicits,
+                cmakeLinkerFlags.libraryFlags
+            );
 
         case StaticLib:
             return staticLibraryTarget(reggaeArtifactPath, intermediateTargets, implicits);