Merge pull request #8528 from jacob-carlborg/reset-state

Add `deinitializeDMD` function to deinitialize the front end
merged-on-behalf-of: unknown

Author: dlang-bot

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

@@ -299,6 +299,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

@@ -404,6 +404,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

@@ -905,6 +905,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:

test/unit/deinitialization.d

@@ -0,0 +1,166 @@
+module deinitialization;
+
+@("global.deinitialize")
+unittest
+{
+    import dmd.globals : global;
+
+    static void assertStructsEqual(T)(const ref T a, const ref T b) @nogc pure nothrow
+    if (is(T == struct))
+    {
+        foreach (i, _; typeof(a.tupleof))
+        {
+            enum name = __traits(identifier, a.tupleof[i]);
+
+            static if (is(typeof(a.tupleof[i]) == const(char*)))
+                assert(a.tupleof[i].fromStringz == b.tupleof[i].fromStringz, name);
+            else
+                assert(a.tupleof[i] == b.tupleof[i], name);
+        }
+    }
+
+    immutable init = global.init;
+    assertStructsEqual(global, init);
+
+    global._init();
+    global.deinitialize();
+
+    assert(global == global.init);
+}
+
+@("Type.deinitialize")
+unittest
+{
+    import dmd.mars : addDefaultVersionIdentifiers, setTarget;
+    import dmd.mtype : Type;
+    import dmd.globals : global;
+
+    assert(Type.stringtable == Type.stringtable.init);
+
+    global._init();
+    setTarget(global.params);
+
+    Type._init();
+    Type.deinitialize();
+
+    global.deinitialize();
+
+    assert(Type.stringtable == Type.stringtable.init);
+}
+
+@("Id.deinitialize")
+unittest
+{
+    import dmd.id : Id;
+
+    static void assertInitialState()
+    {
+        foreach (e ; __traits(allMembers, Id))
+        {
+            static if (!__traits(isStaticFunction, mixin("Id." ~ e)))
+                assert(__traits(getMember, Id, e) is null);
+        }
+    }
+
+    assertInitialState();
+
+    Id.initialize();
+    Id.deinitialize();
+
+    assertInitialState();
+}
+
+@("Module.deinitialize")
+unittest
+{
+    import dmd.dmodule : Module;
+
+    assert(Module.modules is Module.modules.init);
+
+    Module._init();
+    Module.deinitialize();
+
+    assert(Module.modules is Module.modules.init);
+}
+
+@("Target.deinitialize")
+unittest
+{
+    import dmd.globals : Param;
+    import dmd.mars : setTarget;
+    import dmd.target : target, Target;
+
+    static bool isFPTypeProperties(T)()
+    {
+        return is(T == const(typeof(Target.FloatProperties))) ||
+            is (T == const(typeof(Target.DoubleProperties))) ||
+            is (T == const(typeof(Target.RealProperties)));
+    }
+
+    static void assertStructsEqual(T)(const ref T a, const ref T b) @nogc pure nothrow
+    if (is(T == struct))
+    {
+        foreach (i, _; typeof(a.tupleof))
+        {
+            alias Type = typeof(a.tupleof[i]);
+            enum name = __traits(identifier, a.tupleof[i]);
+
+            static if (!isFPTypeProperties!Type)
+                assert(a.tupleof[i] == b.tupleof[i], name);
+        }
+    }
+
+    const init = target.init;
+    assertStructsEqual(target, init);
+
+    Param params;
+    setTarget(params);
+
+    target._init(params);
+    target.deinitialize();
+
+    assertStructsEqual(target, init);
+}
+
+@("Expression.deinitialize")
+unittest
+{
+    import dmd.ctfeexpr : CTFEExp;
+    import dmd.expression : Expression;
+
+    static void assertInitialState()
+    {
+        assert(CTFEExp.cantexp is null);
+        assert(CTFEExp.voidexp is null);
+        assert(CTFEExp.breakexp is null);
+        assert(CTFEExp.continueexp is null);
+        assert(CTFEExp.gotoexp is null);
+        assert(CTFEExp.showcontext is null);
+    }
+
+    assertInitialState();
+
+    Expression._init();
+    Expression.deinitialize();
+
+    assertInitialState();
+}
+
+@("Objc.deinitialize")
+unittest
+{
+    import dmd.objc : Objc, objc;
+
+    assert(objc is null);
+
+    Objc._init();
+    Objc.deinitialize();
+
+    assert(objc is null);
+}
+
+private inout(char)[] fromStringz(inout(char)* cString) @nogc @system pure nothrow
+{
+    import core.stdc.string : strlen;
+    return cString ? cString[0 .. strlen(cString)] : null;
+}