Add deinitializeDMD function to deinitialize the front end

This is a start of being able to restore the global state initialized
by `initDMD` to its original state. It only deinitializes state
initialized by `initDMD`, state store directly inside functions are
not restored.

This is useful to invoke the compiler multiple times within the same
application. This allows to write more fine grained tests for the
compiler, more of a unit test style compared to the current end to end
tests.

Author: jacob-carlborg

download_dub.d

@@ -0,0 +1,105 @@
+// Downloads Dub. For use in the auto-tester CI environment.
+module download_dub;
+
+version (FreeBSD)
+{
+    version (X86_64)
+        enum platform = "freebsd-64";
+    else version (X86)
+        enum platform = "freebsd-32";
+
+    enum binDir = "bin";
+}
+else version (linux)
+{
+    enum platform = "linux";
+
+    version (X86_64)
+        enum binDir = "bin64";
+    else version (X86)
+        enum bin64 = "bin32";
+}
+else version (OSX)
+{
+    enum platform = "osx";
+    enum binDir = "bin";
+}
+else version (Windows)
+{
+    enum platform = "windows";
+    enum binDir = "bin";
+}
+
+version (Posix)
+{
+    enum archiveExtension = "tar.xz";
+    enum exeExtension = "";
+}
+else version (Windows)
+{
+    enum archiveExtension = "7z";
+    enum exeExtension = ".exe";
+}
+
+string resolveLatest()
+{
+    import std.net.curl : get;
+    import std.exception : assumeUnique;
+
+    return get("http://downloads.dlang.org/releases/LATEST").assumeUnique;
+}
+
+string dmdUrl()
+{
+    import std.format : format;
+
+    enum fmt = "http://downloads.dlang.org/releases/2.x/%s/dmd.%s.%s.%s";
+    const version_ = resolveLatest;
+    return format!fmt(version_, version_, platform, archiveExtension);
+}
+
+void unpack(string dmdArchivePath)
+{
+    import std.process : spawnProcess, wait;
+
+    version (Posix)
+        const arguments = ["tar", "xf", dmdArchivePath];
+    else version (Windows)
+        const arguments = ["7z", "x", dmdArchivePath];
+
+    spawnProcess(arguments).wait();
+}
+
+void extractDub(string path, string dest)
+{
+    import std.path : buildPath;
+    import std.file : rename;
+
+    enum filename = "dub" ~ exeExtension;
+    const dubPath = buildPath(path, platform, binDir, filename);
+
+    rename(dubPath, buildPath(dest, filename));
+}
+
+void cleanup(string dmdArchivePath, string dmdPath)
+{
+    import std.file : rmdirRecurse;
+    import std.file : remove;
+
+    rmdirRecurse(dmdPath);
+    remove(dmdArchivePath);
+}
+
+void main()
+{
+    import std.file : getcwd;
+    import std.net.curl : download;
+
+    enum dmdArchivePath = "dmd." ~ archiveExtension;
+    enum dmdPath = "dmd2";
+
+    download(dmdUrl, dmdArchivePath);
+    unpack(dmdArchivePath);
+    extractDub(dmdPath, getcwd);
+    cleanup(dmdArchivePath, dmdPath);
+}

src/dmd/builtin.d

@@ -425,6 +425,17 @@ public extern (C++) void builtin_init()
         add_builtin("_D4core5bitop7_popcntFNaNbNiNfmZi", &eval_popcnt);
 }
 
+/**
+ * Deinitializes the global state of the compiler.
+ *
+ * This can be used to restore the state set by `builtin_init` to its original
+ * state.
+ */
+public void builtinDeinitialize()
+{
+    builtins = builtins.init;
+}
+
 /**********************************
  * Determine if function is a builtin one that we can
  * evaluate at compile time.

src/dmd/dmodule.d

@@ -298,6 +298,17 @@ extern (C++) final class Module : Package
         modules = new DsymbolTable();
     }
 
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `_init` to its original
+     * state.
+     */
+    static void deinitialize()
+    {
+        modules = modules.init;
+    }
+
     extern (C++) __gshared AggregateDeclaration moduleinfo;
 
     const(char)* arg;           // original argument name

src/dmd/expression.d

@@ -640,6 +640,22 @@ extern (C++) abstract class Expression : RootObject
         CTFEExp.showcontext = new CTFEExp(TOK.showCtfeContext);
     }
 
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `_init` to its original
+     * state.
+     */
+    static void deinitialize()
+    {
+        CTFEExp.cantexp = CTFEExp.cantexp.init;
+        CTFEExp.voidexp = CTFEExp.voidexp.init;
+        CTFEExp.breakexp = CTFEExp.breakexp.init;
+        CTFEExp.continueexp = CTFEExp.continueexp.init;
+        CTFEExp.gotoexp = CTFEExp.gotoexp.init;
+        CTFEExp.showcontext = CTFEExp.showcontext.init;
+    }
+
     /*********************************
      * Does *not* do a deep copy.
      */

src/dmd/frontend.d

@@ -76,6 +76,35 @@ void initDMD()
     FileCache._init();
 }
 
+/**
+Deinitializes the global variables of the DMD compiler.
+
+This can be used to restore the state set by `initDMD` to its original state.
+Useful if there's a need for multiple sessions of the DMD compiler in the same
+application.
+*/
+void deinitializeDMD()
+{
+    import dmd.builtin : builtinDeinitialize;
+    import dmd.dmodule : Module;
+    import dmd.expression : Expression;
+    import dmd.globals : global;
+    import dmd.id : Id;
+    import dmd.mtype : Type;
+    import dmd.objc : Objc;
+    import dmd.target : target;
+
+    global.deinitialize();
+
+    Type.deinitialize();
+    Id.deinitialize();
+    Module.deinitialize();
+    target.deinitialize();
+    Expression.deinitialize();
+    Objc.deinitialize();
+    builtinDeinitialize();
+}
+
 /**
 Add import path to the `global.path`.
 Params:

src/dmd/globals.d

@@ -398,6 +398,17 @@ struct Global
         params.color = Console.detectTerminal();
     }
 
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `_init` to its original
+     * state.
+     */
+    void deinitialize()
+    {
+        this = this.init;
+    }
+
     /**
     Returns: the version as the number that would be returned for __VERSION__
     */

src/dmd/id.d

@@ -39,6 +39,17 @@ struct Id
     {
         mixin(msgtable.generate(&initializer));
     }
+
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `initialize` to its original
+     * state.
+     */
+    void deinitialize()
+    {
+        mixin(msgtable.generate(&deinitializer));
+    }
 }
 
 private:
@@ -487,3 +498,9 @@ string initializer(Msgtable m)
 {
     return m.ident ~ ` = Identifier.idPool("` ~ m.name ~ `");`;
 }
+
+// Used to generate the code for each deinitializer.
+string deinitializer(Msgtable m)
+{
+    return m.ident ~ " = Identifier.init;";
+}

src/dmd/mtype.d

@@ -897,6 +897,17 @@ extern (C++) abstract class Type : RootObject
         thash_t = tsize_t;
     }
 
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `_init` to its original
+     * state.
+     */
+    static void deinitialize()
+    {
+        stringtable = stringtable.init;
+    }
+
     final d_uns64 size()
     {
         return size(Loc.initial);

src/dmd/objc.d

@@ -188,6 +188,17 @@ extern(C++) abstract class Objc
             _objc = new Unsupported;
     }
 
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `_init` to its original
+     * state.
+     */
+    static void deinitialize()
+    {
+        _objc = _objc.init;
+    }
+
     abstract void setObjc(ClassDeclaration cd);
     abstract void setObjc(InterfaceDeclaration);
 

src/dmd/target.d

@@ -180,6 +180,17 @@ struct Target
             params.isDragonFlyBSD || params.isOSX;
     }
 
+    /**
+     * Deinitializes the global state of the compiler.
+     *
+     * This can be used to restore the state set by `_init` to its original
+     * state.
+     */
+    void deinitialize()
+    {
+        this = this.init;
+    }
+
     /**
      * Requested target memory alignment size of the given type.
      * Params: