Merge pull request #1588 from 9rnsr/fix9276

Issue 9276 - regression(2.061): Forward reference error

src/template.c

@@ -6455,30 +6455,25 @@ void TemplateMixin::semantic(Scope *sc)
     {
         if (!td->semanticRun)
         {
-            if (td->scope)
-                td->semantic(td->scope);
+            /* Cannot handle forward references if mixin is a struct member,
+             * because addField must happen during struct's semantic, not
+             * during the mixin semantic.
+             * runDeferred will re-run mixin's semantic outside of the struct's
+             * semantic.
+             */
+            semanticRun = PASSinit;
+            AggregateDeclaration *ad = toParent()->isAggregateDeclaration();
+            if (ad)
+                ad->sizeok = SIZEOKfwd;
             else
             {
-                /* Cannot handle forward references if mixin is a struct member,
-                 * because addField must happen during struct's semantic, not
-                 * during the mixin semantic.
-                 * runDeferred will re-run mixin's semantic outside of the struct's
-                 * semantic.
-                 */
-                semanticRun = PASSinit;
-                AggregateDeclaration *ad = toParent()->isAggregateDeclaration();
-                if (ad)
-                    ad->sizeok = SIZEOKfwd;
-                else
-                {
-                    // Forward reference
-                    //printf("forward reference - deferring\n");
-                    scope = scx ? scx : new Scope(*sc);
-                    scope->setNoFree();
-                    scope->module->addDeferredSemantic(this);
-                }
-                return;
+                // Forward reference
+                //printf("forward reference - deferring\n");
+                scope = scx ? scx : new Scope(*sc);
+                scope->setNoFree();
+                scope->module->addDeferredSemantic(this);
             }
+            return;
         }
     }
 
@@ -6597,6 +6592,8 @@ void TemplateMixin::semantic(Scope *sc)
     sc2 = argscope->push(this);
     sc2->offset = sc->offset;
 
+    size_t deferred_dim = sc->module->deferred.dim;
+
     static int nest;
     //printf("%d\n", nest);
     if (++nest > 500)
@@ -6616,6 +6613,33 @@ void TemplateMixin::semantic(Scope *sc)
 
     sc->offset = sc2->offset;
 
+    if (!sc->func && sc->module->deferred.dim > deferred_dim)
+    {
+        sc2->pop();
+        argscope->pop();
+        scy->pop();
+
+        /* Cannot handle forward references if mixin is a struct member,
+         * because addField must happen during struct's semantic, not
+         * during the mixin semantic.
+         * runDeferred will re-run mixin's semantic outside of the struct's
+         * semantic.
+         */
+        semanticRun = PASSinit;
+        AggregateDeclaration *ad = toParent()->isAggregateDeclaration();
+        if (ad)
+            ad->sizeok = SIZEOKfwd;
+        else
+        {
+            // Forward reference
+            //printf("forward reference - deferring\n");
+            scope = scx ? scx : new Scope(*sc);
+            scope->setNoFree();
+            scope->module->addDeferredSemantic(this);
+        }
+        return;
+    }
+
     /* The problem is when to parse the initializer for a variable.
      * Perhaps VarDeclaration::semantic() should do it like it does
      * for initializers inside a function.

test/compilable/imports/test9276decl.d

@@ -0,0 +1,14 @@
+module imports.test9276decl;
+
+import imports.test9276sem, imports.test9276visitors, imports.test9276util;
+
+class Declaration
+{
+    mixin DownCastMethods!TemplateDecl;
+}
+
+class TemplateDecl : OverloadableDecl
+{
+    mixin Visitors;
+}
+

test/compilable/imports/test9276expr.d

@@ -0,0 +1,15 @@
+module imports.test9276expr;
+
+import imports.test9276parser;
+import imports.test9276util;
+
+class Node
+{
+    mixin DownCastMethods!Declaration;
+
+}
+
+class Expression : Node
+{
+}
+

test/compilable/imports/test9276hash.d

@@ -0,0 +1 @@
+module imports.test9276hash;

test/compilable/imports/test9276parser.d

@@ -0,0 +1,4 @@
+module imports.test9276parser;
+
+public import imports.test9276expr, imports.test9276decl;
+

test/compilable/imports/test9276sem.d

@@ -0,0 +1,25 @@
+module imports.test9276sem;
+
+class Declaration
+{
+    mixin Visitors;
+}
+
+template Semantic(T)
+{
+private:
+    struct
+    {
+        import imports.test9276hash;
+    }
+
+}
+
+
+
+import imports.test9276visitors;
+
+class OverloadableDecl : Declaration
+{
+}
+

test/compilable/imports/test9276type.d

@@ -0,0 +1,12 @@
+module imports.test9276type;
+
+import imports.test9276parser;
+
+class Type : Expression     // <- note to Walter.
+{
+}
+
+class BasicType : Type
+{
+}
+

test/compilable/imports/test9276util.d

@@ -0,0 +1,13 @@
+module imports.test9276util;
+
+string _dgliteral(T...)()
+{
+    foreach (t; T)
+        return t.stringof;
+    assert(0);
+}
+template DownCastMethods(T...)
+{
+    enum x = _dgliteral!T;
+}
+

test/compilable/imports/test9276visitors.d

@@ -0,0 +1,16 @@
+module imports.test9276visitors;
+
+template Visitors()
+{
+    mixin Semantic!(typeof(this));
+    mixin DeepDup!(typeof(this));
+}
+
+import imports.test9276type;
+
+template DeepDup(T) if (is(T : BasicType))
+{}
+
+template DeepDup(T)
+{}
+

test/compilable/test9276.d

@@ -0,0 +1,6 @@
+// REQUIRED_ARGS: compilable/imports/test9276parser.d
+
+
+// This is a dummy module for compilable test
+void main()
+{}

test/runnable/xtest46.d

@@ -4831,7 +4831,7 @@ void test3091(inout int = 0)
 
 template Id6837(T)
 {
-	alias T Id6837;
+    alias T Id6837;
 }
 static assert(is(Id6837!(shared const int) == shared const int));
 static assert(is(Id6837!(shared inout int) == shared inout int));
@@ -5703,17 +5703,17 @@ struct S162
 {
     static int generateMethodStubs( Class )()
     {
-	int text;
+        int text;
 
-	foreach( m; __traits( allMembers, Class ) )
-	{
-	    static if( is( typeof( mixin( m ) ) ) && is( typeof( mixin( m ) ) == function ) )
-	    {
-		pragma(msg, __traits( getOverloads, Class, m ));
-	    }
-	}
+        foreach( m; __traits( allMembers, Class ) )
+        {
+            static if( is( typeof( mixin( m ) ) ) && is( typeof( mixin( m ) ) == function ) )
+            {
+                pragma(msg, __traits( getOverloads, Class, m ));
+            }
+        }
 
-	return text;
+        return text;
     }
 
     enum int ttt = generateMethodStubs!( S162 )();
@@ -5776,10 +5776,10 @@ mixin template DefineCoreType(string type)
 
         static void instance()
         {
-	    x = 3;
+            x = 3;
         }
 
-	X164!() xxx;
+        X164!() xxx;
     }
 }