Move frontend utility functions from the DUB packag to dmd.frontend

Author: wilzbach

src/dmd/frontend.d

@@ -14,36 +14,28 @@
  */
 module dmd.frontend;
 
-/**
-Initializes the DMD compiler
+import dmd.dmodule : Module;
+import std.range.primitives : isInputRange, ElementType;
+import std.traits : isNarrowString;
+
+/*
+Initializes the global variables of the DMD compiler.
+This needs to be done $(I before) calling any function.
 */
 void initDMD()
 {
+    import dmd.builtin : builtin_init;
     import dmd.dmodule : Module;
+    import dmd.expression : Expression;
     import dmd.globals : global;
     import dmd.id : Id;
+    import dmd.mars : addDefaultVersionIdentifiers;
     import dmd.mtype : Type;
-    import dmd.target : Target;
-    import dmd.expression : Expression;
     import dmd.objc : Objc;
-    import dmd.builtin : builtin_init;
+    import dmd.target : Target;
 
-    global._init;
-
-    version(linux)
-        global.params.isLinux = 1;
-    else version(OSX)
-        global.params.isOSX = 1;
-    else version(FreeBSD)
-        global.params.isFreeBSD = 1;
-    else version(Windows)
-        global.params.isWindows = 1;
-    else version(Solaris)
-        global.params.isSolaris = 1;
-    else version(OpenBSD)
-        global.params.isOpenBSD = 1;
-    else
-        static assert(0, "OS not supported yet.");
+    global._init();
+    addDefaultVersionIdentifiers();
 
     Type._init();
     Id.initialize();
@@ -54,3 +46,235 @@ void initDMD()
     builtin_init();
 }
 
+/**
+Add import path to the `global.path`.
+Params:
+    path = import to add
+*/
+void addImport(string path)
+{
+    import dmd.globals : global;
+    import dmd.arraytypes : Strings;
+    import std.string : toStringz;
+
+    if (global.path is null)
+        global.path = new Strings();
+
+    global.path.push(path.toStringz);
+}
+
+/**
+Searches for a `dmd.conf`.
+
+Params:
+    dmdFilePath = path to the current DMD executable
+
+Returns: full path to the found `dmd.conf`, `null` otherwise.
+*/
+string findDMDConfig(string dmdFilePath)
+{
+    import dmd.dinifile : findConfFile;
+    import std.string : fromStringz, toStringz;
+
+    auto f = findConfFile(dmdFilePath.toStringz, "dmd.conf");
+    if (f is null)
+        return null;
+
+    return f.fromStringz.idup;
+}
+
+/**
+Searches for a `ldc2.conf`.
+
+Params:
+    ldcFilePath = path to the current LDC executable
+
+Returns: full path to the found `ldc2.conf`, `null` otherwise.
+*/
+string findLDCConfig(string ldcFilePath)
+{
+    import std.file : getcwd;
+    import std.path : buildPath, dirName;
+    import std.algorithm.iteration : filter;
+    import std.file : exists;
+
+    auto execDir = ldcFilePath.dirName;
+
+    immutable ldcConfig = "ldc2.conf";
+    // https://wiki.dlang.org/Using_LDC
+    auto ldcConfigs = [
+        getcwd.buildPath(ldcConfig),
+        execDir.buildPath(ldcConfig),
+        execDir.dirName.buildPath("etc", ldcConfig),
+        "~/.ldc".buildPath(ldcConfig),
+        execDir.buildPath("etc", ldcConfig),
+        execDir.buildPath("etc", "ldc", ldcConfig),
+        "/etc".buildPath(ldcConfig),
+        "/etc/ldc".buildPath(ldcConfig),
+    ].filter!exists;
+    if (ldcConfigs.empty)
+        return null;
+
+    return ldcConfigs.front;
+}
+
+/**
+Detect the currently active compiler.
+Returns: full path to the executable of the found compiler, `null` otherwise.
+*/
+// TODO: use a more fault-proof detection
+string findCompiler()
+{
+    import std.process : env = environment, execute;
+
+    auto dmdEnv = env.get("DMD", "dmd");
+    auto whichDMD = execute(["which", dmdEnv]);
+    if (whichDMD.status != 0)
+        return null;
+
+    return whichDMD.output;
+}
+
+/**
+Parses a `dmd.conf` or `ldc2.conf` config file and returns defined import paths.
+
+Params:
+    iniFile = iniFile to parse imports from
+    execDir = directory of the compiler binary
+
+Returns: forward range of import paths found in `iniFile`
+*/
+auto parseImportPathsFromConfig(string iniFile, string execDir)
+{
+    import std.algorithm, std.range, std.regex;
+    import std.stdio : File;
+    import std.path : buildNormalizedPath;
+
+    alias expandConfigVariables = a => a.drop(2) // -I
+                                // "set" common config variables
+                                .replace("%@P%", execDir)
+                                .replace("%%ldcbinarypath%%", execDir);
+
+    // search for all -I imports in this file
+    alias searchForImports = l => l.matchAll(`-I[^ "]+`.regex).joiner.map!expandConfigVariables;
+
+    return File(iniFile, "r")
+        .byLineCopy
+        .map!searchForImports
+        .joiner
+        // remove duplicated imports paths
+        .array
+        .sort
+        .uniq
+        .map!buildNormalizedPath;
+}
+
+/**
+Finds a dmd.conf and parses it for import paths.
+This depends on the `$DMD` environment variable.
+If it's set to `ldmd`, it will try to detect and parse an `ldc2.conf` instead.
+
+Returns:
+    A forward range of normalized import paths.
+*/
+auto findImportPaths()
+{
+    import std.algorithm.searching : canFind;
+    import std.file : exists;
+    import std.path : dirName;
+
+    string execFilePath = findCompiler;
+    assert(execFilePath !is null, "No D compiler found.");
+
+    immutable execDir = execFilePath.dirName;
+
+    string iniFile;
+    if (execFilePath.canFind("ldmd") || execFilePath.canFind("ldc"))
+        iniFile = findLDCConfig(execFilePath);
+    else
+        iniFile = findDMDConfig(execFilePath);
+
+    assert(iniFile !is null, "No valid config found.");
+    assert(iniFile.exists, "No valid config found.");
+    return iniFile.parseImportPathsFromConfig(execDir);
+}
+
+/**
+Parse a module from a string.
+
+Params:
+    fileName = file to parse
+    code = text to use instead of opening the file
+
+Returns: the parsed module object
+*/
+Module parseModule(string fileName, string code = null)
+{
+    import dmd.astcodegen : ASTCodegen;
+    import dmd.globals : Loc;
+    import dmd.parse : Parser;
+    import dmd.statement : Identifier;
+    import dmd.tokens : TOKeof;
+    import std.string : toStringz;
+
+    auto parse(Module m, string code)
+    {
+        scope p = new Parser!ASTCodegen(m, code, false);
+        p.nextToken; // skip the initial token
+        auto members = p.parseModule;
+        assert(!p.errors, "Parsing error occurred.");
+        assert(p.token.value == TOKeof, "Didn't reach the end token. Did an error occur?");
+        return members;
+    }
+
+    Identifier id = Identifier.idPool(fileName);
+    auto m = new Module(fileName.toStringz, id, 0, 0);
+    if (code !is null)
+        m.members = parse(m, code);
+    else
+    {
+        m.read(Loc());
+        m.parse();
+    }
+
+    return m;
+}
+
+/**
+Run full semantic analysis on a module.
+*/
+void fullSemantic(Module m)
+{
+    import dmd.dsymbolsem : dsymbolSemantic;
+    import dmd.semantic2 : semantic2;
+    import dmd.semantic3 : semantic3;
+
+    m.importedFrom = m;
+    m.importAll(null);
+    m.dsymbolSemantic(null);
+    m.semantic2(null);
+    m.semantic3(null);
+}
+
+/**
+Pretty print a module.
+
+Returns:
+    Pretty printed module as string.
+*/
+string prettyPrint(Module m)
+{
+    import dmd.root.outbuffer: OutBuffer;
+    import dmd.hdrgen : HdrGenState, PrettyPrintVisitor;
+
+    OutBuffer buf = { doindent: 1 };
+    HdrGenState hgs = { fullDump: 1 };
+    scope PrettyPrintVisitor ppv = new PrettyPrintVisitor(&buf, &hgs);
+    m.accept(ppv);
+
+    import std.string : replace, fromStringz;
+    import std.exception : assumeUnique;
+
+    auto generated = buf.extractData.fromStringz.replace("\t", "    ");
+    return generated.assumeUnique;
+}

src/dmd/mars.d

@@ -1311,7 +1311,7 @@ private void setDefaultLibrary()
  * variable and config file) in order to add final flags (such as `X86_64` or
  * the `CRuntime` used).
  */
-private void addDefaultVersionIdentifiers()
+void addDefaultVersionIdentifiers()
 {
     VersionCondition.addPredefinedGlobalIdent("DigitalMars");
     static if (TARGET_WINDOS)