Go a bit further

Author: kinke

dmd/dsymbolsem.d

@@ -6074,21 +6074,7 @@ void templateInstanceSemantic(TemplateInstance tempinst, Scope* sc, Expressions*
             printf("\tit's a match with instance %p, %d\n", tempinst.inst, tempinst.inst.semanticRun);
         }
 
-        if (tempinst.minst)
-        {
-            bool moduleHasSiblingAlready = false;
-            for (auto ti = tempinst.primaryInst; ti; ti = ti.tnext)
-            {
-                if (ti.memberOf is tempinst.minst)
-                {
-                    moduleHasSiblingAlready = true;
-                    break;
-                }
-            }
-
-            if (!moduleHasSiblingAlready)
-                tempinst.appendToModuleMember();
-        }
+        tempinst.appendToModuleMember();
 
         return;
     }

dmd/dtemplate.d

@@ -6068,161 +6068,7 @@ extern (C++) class TemplateInstance : ScopeDsymbol
      */
     final bool needsCodegen()
     {
-        // Now -allInst is just for the backward compatibility.
-        if (global.params.allInst)
-        {
-            //printf("%s minst = %s, enclosing (%s).isNonRoot = %d\n",
-            //    toPrettyChars(), minst ? minst.toChars() : NULL,
-            //    enclosing ? enclosing.toPrettyChars() : NULL, enclosing && enclosing.inNonRoot());
-            if (enclosing)
-            {
-                /* https://issues.dlang.org/show_bug.cgi?id=14588
-                 * If the captured context is not a function
-                 * (e.g. class), the instance layout determination is guaranteed,
-                 * because the semantic/semantic2 pass will be executed
-                 * even for non-root instances.
-                 */
-                if (!enclosing.isFuncDeclaration())
-                    return true;
-
-                /* https://issues.dlang.org/show_bug.cgi?id=14834
-                 * If the captured context is a function,
-                 * this excessive instantiation may cause ODR violation, because
-                 * -allInst and others doesn't guarantee the semantic3 execution
-                 * for that function.
-                 *
-                 * If the enclosing is also an instantiated function,
-                 * we have to rely on the ancestor's needsCodegen() result.
-                 */
-                if (TemplateInstance ti = enclosing.isInstantiated())
-                    return ti.needsCodegen();
-
-                /* https://issues.dlang.org/show_bug.cgi?id=13415
-                 * If and only if the enclosing scope needs codegen,
-                 * this nested templates would also need code generation.
-                 */
-                return !enclosing.inNonRoot();
-            }
-            return true;
-        }
-
-        if (!minst)
-        {
-            // If this is a speculative instantiation,
-            // 1. do codegen if ancestors really needs codegen.
-            // 2. become non-speculative if siblings are not speculative
-
-            TemplateInstance tnext = this.tnext;
-            TemplateInstance tinst = this.tinst;
-            // At first, disconnect chain first to prevent infinite recursion.
-            this.tnext = null;
-            this.tinst = null;
-
-            // Determine necessity of tinst before tnext.
-            if (tinst && tinst.needsCodegen())
-            {
-                minst = tinst.minst; // cache result
-                assert(minst);
-                assert(minst.isRoot() || minst.rootImports());
-                return true;
-            }
-            if (tnext && (tnext.needsCodegen() || tnext.minst))
-            {
-                minst = tnext.minst; // cache result
-                assert(minst);
-                return minst.isRoot() || minst.rootImports();
-            }
-
-            // Elide codegen because this is really speculative.
-            return false;
-        }
-
-        /* Even when this is reached to the codegen pass,
-         * a non-root nested template should not generate code,
-         * due to avoid ODR violation.
-         */
-        if (enclosing && enclosing.inNonRoot())
-        {
-            if (tinst)
-            {
-                auto r = tinst.needsCodegen();
-                minst = tinst.minst; // cache result
-                return r;
-            }
-            if (tnext)
-            {
-                auto r = tnext.needsCodegen();
-                minst = tnext.minst; // cache result
-                return r;
-            }
-            return false;
-        }
-
-        if (true)//global.params.useUnitTests)
-        {
-            // Prefer instantiations from root modules, to maximize link-ability.
-            if (minst.isRoot())
-                return true;
-
-            TemplateInstance tnext = this.tnext;
-            TemplateInstance tinst = this.tinst;
-            this.tnext = null;
-            this.tinst = null;
-
-            if (tinst && tinst.needsCodegen())
-            {
-                minst = tinst.minst; // cache result
-                assert(minst);
-                assert(minst.isRoot() || minst.rootImports());
-                return true;
-            }
-            if (tnext && tnext.needsCodegen())
-            {
-                minst = tnext.minst; // cache result
-                assert(minst);
-                assert(minst.isRoot() || minst.rootImports());
-                return true;
-            }
-
-            // https://issues.dlang.org/show_bug.cgi?id=2500 case
-            if (false)//minst.rootImports())
-                return true;
-
-            // Elide codegen because this is not included in root instances.
-            return false;
-        }
-        else
-        {
-            // Prefer instantiations from non-root module, to minimize object code size.
-
-            /* If a TemplateInstance is ever instantiated by non-root modules,
-             * we do not have to generate code for it,
-             * because it will be generated when the non-root module is compiled.
-             *
-             * But, if the non-root 'minst' imports any root modules, it might still need codegen.
-             *
-             * The problem is if A imports B, and B imports A, and both A
-             * and B instantiate the same template, does the compilation of A
-             * or the compilation of B do the actual instantiation?
-             *
-             * See https://issues.dlang.org/show_bug.cgi?id=2500.
-             */
-            if (!minst.isRoot() && !minst.rootImports())
-                return false;
-
-            TemplateInstance tnext = this.tnext;
-            this.tnext = null;
-
-            if (tnext && !tnext.needsCodegen() && tnext.minst)
-            {
-                minst = tnext.minst; // cache result
-                assert(!minst.isRoot());
-                return false;
-            }
-
-            // Do codegen because this is not included in non-root instances.
-            return true;
-        }
+        return minst && minst.isRoot();
     }
 
     /**********************************************
@@ -7165,9 +7011,14 @@ extern (C++) class TemplateInstance : ScopeDsymbol
         }
         */
 
-        if (!mi)
+        if (!mi || !mi.isRoot())
             return null;
 
+        // skip if a sibling has already been added
+        for (auto sibling = primaryInst; sibling; sibling = sibling.tnext)
+            if (sibling.memberOf is mi)
+                return null;
+
         /++
         //printf("%s.appendToModuleMember() enclosing = %s mi = %s\n",
         //    toPrettyChars(),
@@ -7228,10 +7079,20 @@ extern (C++) class TemplateInstance : ScopeDsymbol
         Dsymbols* a = mi.members;
         a.push(this);
         memberOf = mi;
-        if (mi.semanticRun >= PASS.semantic2done && mi.isRoot())
-            Module.addDeferredSemantic2(this);
-        if (mi.semanticRun >= PASS.semantic3done && mi.isRoot())
-            Module.addDeferredSemantic3(this);
+        if (!primaryInst)
+        {
+            if (mi.semanticRun >= PASS.semantic2done)
+                Module.addDeferredSemantic2(this);
+            if (mi.semanticRun >= PASS.semantic3done)
+                Module.addDeferredSemantic3(this);
+        }
+        else if (!primaryInst.memberOf || !primaryInst.memberOf.isRoot())
+        {
+            //printf(".: deferredSemantic for non-root primaryInst: %s\n", primaryInst.toChars());
+            Module.addDeferredSemantic2(primaryInst);
+            Module.addDeferredSemantic3(primaryInst);
+            primaryInst.memberOf = mi; // HACK
+        }
         return a;
     }
 

gen/declarations.cpp

@@ -366,18 +366,16 @@ class CodegenVisitor : public Visitor {
       return;
     }
 
-    auto members = decl->primaryInst && decl->primaryInst->members
-                       ? decl->primaryInst->members /*Dsymbol::arraySyntaxCopy(
-                             decl->primaryInst->members)*/
-                       : decl->members;
+    auto members =
+        decl->primaryInst ? decl->primaryInst->members : decl->members;
 
     if (!members) {
       Logger::println("Has no members, skipping.");
       return;
     }
 
     // FIXME: This is #673 all over again.
-    if (false) { // (!decl->needsCodegen()) {
+    if (!decl->needsCodegen()) {
       // Force codegen if this is a templated function with pragma(inline,
       // true).
       if (members->length == 1 && (*members)[0]->isFuncDeclaration() &&

gen/modules.cpp

@@ -606,7 +606,7 @@ void codegenModule(IRState *irs, Module *m) {
 
   // process module members
   // NOTE: m->members may grow during codegen
-  for (unsigned k = 0; k < m->members->length; k++) {
+  for (d_size_t k = 0; k < m->members->length; k++) {
     Dsymbol *dsym = (*m->members)[k];
     assert(dsym);
     Declaration_codegen(dsym);

gen/runtime.cpp

@@ -110,10 +110,10 @@ static void checkForImplicitGCCall(const Loc &loc, const char *name) {
 ////////////////////////////////////////////////////////////////////////////////
 
 bool initRuntime() {
-  Logger::println("*** Initializing D runtime declarations ***");
-  LOG_SCOPE;
-
   if (!M) {
+    Logger::println("*** Initializing D runtime declarations ***");
+    LOG_SCOPE;
+
     buildRuntimeModule();
   }