Ticket #125: forwardref-965.diff

a/dmd/aggregate.h

@@ -62 +62 @@
-                // 1: size is correct
-                // 2: cannot determine size; fwd referenced
-    int isdeprecated;       // !=0 if deprecated
-    Scope *scope;       // !=NULL means context to use
-
-    // Special member functions
-    InvariantDeclaration *inv;      // invariant
@@ -104 +103 @@
-    Symbol *toInitializer();
-
-    AggregateDeclaration *isAggregateDeclaration() { return this; }
+
+    // LDC
+    int sc_offset;      // saved next offset in aggregate
-};
-
-struct AnonymousAggregateDeclaration : AggregateDeclaration
@@ -131 +133 @@
-    Dsymbol *syntaxCopy(Dsymbol *s);
-    void semantic(Scope *sc);
-    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+
+    //LDC, override to allow searching in partially semantic'ed structs
+    Dsymbol *search(Loc, Identifier *ident, int flags);
+
+    //LDC, for deferring
+    int deferState;
+    virtual bool isMemberReorderable(Dsymbol* s);
+
-    char *mangle();
-    const char *kind();
-    Expression *cloneMembers();
@@ -152 +162 @@
-    const char *kind();
-
-    UnionDeclaration *isUnionDeclaration() { return this; }
+
+    // LDC, overload to reset offset to zero after each member
+    virtual void postMemberSemantic(Scope* sc);
-};
-
-// warning: two classes with the same base class share the same
@@ -216 +229 @@
-    VarDeclaration *vthis;      // 'this' parameter if this class is nested
-
-    int inuse;              // to prevent recursive attempts
+
+    //LDC, for deferring
+    int deferState;
-
-    ClassDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses);
-    Dsymbol *syntaxCopy(Dsymbol *s);

a/dmd/attrib.c

@@ -43 +43 @@
-    : Dsymbol()
-{
-    this->decl = decl;
+    member_semantic_started = false;
+    included_decls = NULL;
-}
-
-Array *AttribDeclaration::include(Scope *sc, ScopeDsymbol *sd)
@@ -65 +67 @@
-    return m;
-}
-
+// shares code with ScopeDsymbol::callSemanticOnMembers
+void AttribDeclaration::callSemanticOnMembers(Scope* sc, Array* members)
+{
+    if (!members)
+    return;
+
+    // first add everything to remaining_semantic
+    if (!member_semantic_started) {
+    for (int i = 0; i < members->dim; i++)
+        remaining_semantic.push_back( (Dsymbol*)members->data[i] );
+    member_semantic_started = true;
+    }
+
+    int failed = 0;
+
+    // last defer exception that was caught. stored for the error message inside
+    DeferException* lastdefer;
+
+    // if we deferred an order dependent member, save it here
+    // we will then skip all order dependent members until this is reached again
+    Dsymbol *deferredOrderDependent = NULL;
+
+    while (!remaining_semantic.empty() && failed != remaining_semantic.size())
+    {   Dsymbol *s;
+    s = remaining_semantic[0];
+    remaining_semantic.pop_front();
+
+    // if we deferred something order dependent, skip other
+    // order dependent ones for one iteration
+    if (deferredOrderDependent == s)
+        deferredOrderDependent = NULL;
+    if (deferredOrderDependent && !isMemberReorderable(s)) {
+        ++failed;
+        remaining_semantic.push_back(s);
+        continue;
+    }
+
+    try {
+        runSemantic(s, sc);
+    } catch (DeferException* deferexc) {
+        lastdefer = deferexc;
+        ++failed;
+        remaining_semantic.push_back(s);
+        if (!isMemberReorderable(s))
+        deferredOrderDependent = s;
+        continue;
+    }
+
+    failed = 0;
+    postMemberSemantic(sc);
+    }
+
+    if (!remaining_semantic.empty())
+    {
+    assert(lastdefer);
+
+    // reorder members into a valid state if necessary
+    if (deferredOrderDependent)
+        while (remaining_semantic[0] != deferredOrderDependent) {
+        Dsymbol* s = remaining_semantic[0];
+        remaining_semantic.pop_front();
+        remaining_semantic.push_back(s);
+        }
+
+    throw lastdefer;
+    }
+}
+
-void AttribDeclaration::semantic(Scope *sc)
-{
-
+
+
-
-    //printf("\tAttribDeclaration::semantic '%s', d = %p\n",toChars(), d);
-
-
-
-
-
-
-
-
-
+
-}
-
-void AttribDeclaration::semantic2(Scope *sc)
@@ -290 +353 @@
-    if (stc & (STCauto | STCscope | STCstatic | STCextern))
-        sc->stc &= ~(STCauto | STCscope | STCstatic | STCextern);
-    sc->stc |= stc;
-
-
-
-
-
-
+
-    sc->stc = stc_save;
-    }
-    else
@@ -364 +422 @@
-    {   enum LINK linkage_save = sc->linkage;
-
-    sc->linkage = linkage;
-
-
-
-
-
-
+
-    sc->linkage = linkage_save;
-    }
-    else
@@ -454 +507 @@
-
-    sc->protection = protection;
-    sc->explicitProtection = 1;
-
-
-
-
-
-
+
-    sc->protection = protection_save;
-    sc->explicitProtection = explicitProtection_save;
-    }
@@ -513 +561 @@
-
-    //printf("\tAlignDeclaration::semantic '%s'\n",toChars());
-    if (decl)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-    }
-    else
-    assert(0 && "what kind of align use triggers this?");
-}
-
+void AlignDeclaration::runSemantic(Dsymbol* s, Scope* sc)
+{
+    unsigned salign_save = sc->structalign;
+
+    if (s->isStructDeclaration() && salign == 1)
+    {
+    sc->structalign = salign;
+    s->semantic(sc);
+    sc->structalign = salign_save;
+    }
+    else
+    {
+    s->semantic(sc);
+    }
+}
-
-void AlignDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
-{
@@ -550 +597 @@
-{
-    this->loc = loc;
-    this->isunion = isunion;
-    this->scope = NULL;
-    this->sem = 0;
+
+    sc_offset = -1;
-}
-
-Dsymbol *AnonDeclaration::syntaxCopy(Dsymbol *s)
@@ -563 +611 @@
-    return ad;
-}
-
+// copied from StructDeclaration::isMemberReorderable
+bool AnonDeclaration::isMemberReorderable(Dsymbol* s)
+{
+    if (
+    s->isVarDeclaration() ||
+    s->isAttribDeclaration()
+    )
+    return false;
+    return true;
+}
+
+void AnonDeclaration::postMemberSemantic(Scope* sc)
+{
+    if (isunion)
+    sc->offset = 0;
+}
+
-void AnonDeclaration::semantic(Scope *sc)
-{
-    //printf("\tAnonDeclaration::semantic %s %p\n", isunion ? "union" : "struct", this);
-
-    Scope *scx = NULL;
-    if (scope)
-    {   sc = scope;
-    scx = scope;
-    scope = NULL;
-    }
-
-    assert(sc->parent);
-
@@ -587 +645 @@
-
-    if (decl)
-    {
-    AnonymousAggregateDeclaration aad;
-    int adisunion;
-
-    if (sc->anonAgg)
@@ -606 +663 @@
-    sc->stc &= ~(STCauto | STCscope | STCstatic);
-    sc->inunion = isunion;
-    sc->offset = 0;
+    if (sc_offset >= 0)
+        sc->offset = sc_offset;
+ 
-    sc->flags = 0;
-    aad.structalign = sc->structalign;
-    aad.parent = ad;
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    }
+    
-    sc = sc->pop();
-
-    // If failed due to forward references, unwind and try again later
-    if (aad.sizeok == 2)
-    {
-        ad->sizeok = 2;
-        //printf("\tsetting ad->sizeok %p to 2\n", ad);
-        if (!sc->anonAgg)
-        {
-        scope = scx ? scx : new Scope(*sc);
-        scope->setNoFree();
-        scope->module->addDeferredSemantic(this);
-        }
-        //printf("\tforward reference %p\n", this);
-        return;
-    }
-    if (sem == 0)
-    {   Module::dprogress++;
-        sem = 1;
@@ -1338 +1380 @@
-
-void StaticIfDeclaration::semantic(Scope *sc)
-{
-
+
+
-
-    //printf("\tStaticIfDeclaration::semantic '%s', d = %p\n",toChars(), d);
-d
+included_decls
-    {
-    if (!addisdone)
-    {   AttribDeclaration::addMember(sc, sd, 1);
-        addisdone = 1;
-    }
-
-
-
-
-
-
-
+
-    }
-}
-

a/dmd/attrib.h

@@ -16 +16 @@
-#endif /* __DMC__ */
-
-#include "dsymbol.h"
+#include "aggregate.h"
-
-struct Expression;
-struct Statement;
@@ -52 +53 @@
-
-    virtual void toObjFile(int multiobj);           // compile to .obj file
-    int cvMember(unsigned char *p);
+
+    // LDC
+    Array *included_decls;
+    std::deque<Dsymbol*> remaining_semantic;
+    bool member_semantic_started;
+
+    void callSemanticOnMembers(Scope* sc, Array* members);
+    virtual void runSemantic(Dsymbol* s, Scope* sc) { s->semantic(sc); }
+    virtual void postMemberSemantic(Scope* sc) {};
+    virtual bool isMemberReorderable(Dsymbol* sym) { return true; }
-};
-
-struct StorageClassDeclaration: AttribDeclaration
@@ -94 +105 @@
-    Dsymbol *syntaxCopy(Dsymbol *s);
-    void semantic(Scope *sc);
-    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+
+    void runSemantic(Dsymbol* s, Scope* sc);
-};
-
-struct AnonDeclaration : AttribDeclaration
-{
-    int isunion;
-    Scope *scope;       // !=NULL means context to use
-    int sem;            // 1 if successful semantic()
-
-    AnonDeclaration(Loc loc, int isunion, Array *decl);
@@ -110 +122 @@
-
-    // LDC
-    void toObjFile(int multiobj);           // compile to .obj file
+
+    void postMemberSemantic(Scope* sc);
+    bool isMemberReorderable(Dsymbol* sym);
+    int sc_offset;      // saved next offset in aggregate
+    AnonymousAggregateDeclaration aad;
-};
-
-struct PragmaDeclaration : AttribDeclaration

a/dmd/class.c

@@ -40 +40 @@
-    if (baseclasses)
-    this->baseclasses = *baseclasses;
-    baseClass = NULL;
+
+    deferState = 0;
-
-    interfaces_dim = 0;
-    interfaces = NULL;
@@ -216 +218 @@
-void ClassDeclaration::semantic(Scope *sc)
-{   int i;
-    unsigned offset;
+    Scope scsave;
+    Scope *scx = NULL;
-
-    //printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
-    //printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");
@@ -223 +227 @@
-
-    //{ static int n;  if (++n == 20) *(char*)0=0; }
-
+int continueAt = deferState;
+if (deferState > 0) 
+    deferState = 0;
+switch (continueAt) {
+case 0:
+
-    if (!ident)     // if anonymous class
-    {   char *id = "__anonclass";
-
-    ident = Identifier::generateId(id);
-    }
-
-
-
-
-
+
+
-
-   
-   
-
+    
+    
+
-    if (!members)           // if forward reference
-    {   //printf("\tclass '%s' is forward referenced\n", toChars());
-    return;
-    }
-    if (symtab)
-
-
-
-
+
+
-    }
-    else
-    symtab = new DsymbolTable();
-
-    Scope *scx = NULL;
-    if (scope)
-    {   sc = scope;
-    scx = scope;        // save so we don't make redundant copies
-    scope = NULL;
-    }
-#ifdef IN_GCC
-    methods.setDim(0);
-#endif
@@ -286 +286 @@
-        i++;
-    }
-
+case 1:
-    // See if there's a base class as first in baseclasses[]
-    if (baseclasses.dim)
-    {   TypeClass *tc;
@@ -327 +328 @@
-            goto L7;
-            }
-        }
-scope
+deferState > 0
-        {
-            //error("forward reference of base class %s", baseClass->toChars());
-            // Forward reference of base class, try again later
-            //printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
-
-
-
+
+
-            return;
+            //throw new DeferException(loc, "forward reference of base class %s", tc->sym->toChars());
-        }
-        else
-        {   baseClass = tc->sym;
@@ -346 +347 @@
-    }
-    }
-
+case 2:
-    // Treat the remaining entries in baseclasses as interfaces
-    // Check for errors, handle forward references
-    for (i = (baseClass ? 1 : 0); i < baseclasses.dim; )
@@ -388 +390 @@
-        }
-
-        b->base = tc->sym;
-scope
+deferState > 0
-        {
-        //error("forward reference of base class %s", baseClass->toChars());
-        // Forward reference of base, try again later
-        //printf("\ttry later, forward reference of base %s\n", baseClass->toChars());
-
-
-
+
+
-        return;
+        //throw new DeferException(loc, "forward reference of interface %s", baseClass->toChars());
-        }
-    }
-    i++;
@@ -532 +534 @@
-    if (storage_class & STCabstract)
-    isabstract = 1;
-
+    structalign = 8;
+    if (baseClass)
+    {   sc_offset = baseClass->structsize;
+    alignsize = baseClass->alignsize;
+//  if (isnested)
+//      sc->offset += PTRSIZE;  // room for uplevel context pointer
+    }
+    else
+    {   sc_offset = 2*PTRSIZE;      // allow room for vptr[] and monitor
+    alignsize = PTRSIZE;
+    }
+    structsize = sc_offset;
+    sizeok = 0;
+
+case 3:
-    sc = sc->push(this);
-    sc->stc &= ~(STCfinal | STCauto | STCscope | STCstatic |
-         STCabstract | STCdeprecated);
@@ -552 +569 @@
-    sc->protection = PROTpublic;
-    sc->explicitProtection = 0;
-    sc->structalign = 8;
-    structalign = sc->structalign;
-    if (baseClass)
-    {   sc->offset = baseClass->structsize;
-    alignsize = baseClass->alignsize;
-//  if (isnested)
-//      sc->offset += PTRSIZE;  // room for uplevel context pointer
-    }
-    else
-    {   sc->offset = 2*PTRSIZE;     // allow room for vptr[] and monitor
-    alignsize = PTRSIZE;
-    }
-    structsize = sc->offset;
-    Scope scsave = *sc;
-    int members_dim = members->dim;
-    sizeok = 0;
-    for (i = 0; i < members_dim; i++)
-    {
-    Dsymbol *s = (Dsymbol *)members->data[i];
-    s->semantic(sc);
-    }
-
-
-
-
-
-
-
-
+
+
-
+    scsave = *sc;
+
+    try {
+    callSemanticOnMembers(sc);
+    } catch (DeferException* deferexc) {
+    sc_offset = sc->offset;
+    deferState = 3;
-    sc = sc->pop();
-
-
-
-
-
-
-
+
-    }
-
-    //printf("\tsemantic('%s') successful\n", toChars());
@@ -679 +672 @@
-    }
-#endif
-    //printf("-ClassDeclaration::semantic(%s), type = %p\n", toChars(), type);
+
+    deferState = -1;
+case -1:
+    break;
+default:
+    assert(0 && "deferState for classes must be between -1 and 3");
+} // switch for deferred calling
-}
-
-void ClassDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
@@ -775 +775 @@
-    Dsymbol *s;
-
-    //printf("%s.ClassDeclaration::search('%s')\n", toChars(), ident->toChars());
-
-
+
-
-
-
-
-
+
+
+
-    }
-
-    s = ScopeDsymbol::search(loc, ident, flags);
-    if (!s)
-    {
-    // Search bases classes in depth-first, left to right order
@@ -996 +993 @@
-
-void InterfaceDeclaration::semantic(Scope *sc)
-{   int i;
+    Scope *scx = NULL;
-
+int continueAt = deferState;
+if (deferState > 0)
+    deferState = 0;
+switch (continueAt) {
+case 0:
-    //printf("InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type);
-    if (inuse)
-    return;
-
-{  
-   
-
+
+
+    
+
-    if (!members)           // if forward reference
-    {   //printf("\tinterface '%s' is forward referenced\n", toChars());
-    return;
-    }
-    if (symtab)         // if already done
-  if (!scope)
-    
+
+
-    }
-    else
-    symtab = new DsymbolTable();
-
-    Scope *scx = NULL;
-    if (scope)
-    {   sc = scope;
-    scx = scope;        // save so we don't make redundant copies
-    scope = NULL;
-    }
-
-    if (sc->stc & STCdeprecated)
-    {
@@ -1048 +1044 @@
-        i++;
-    }
-
+case 1:
-    // Check for errors, handle forward references
-    for (i = 0; i < baseclasses.dim; )
-    {   TypeClass *tc;
@@ -1084 +1081 @@
-        baseclasses.remove(i);
-        continue;
-        }
-scope
+deferState > 0
-        {
-        //error("forward reference of base class %s", baseClass->toChars());
-        // Forward reference of base, try again later
-        //printf("\ttry later, forward reference of base %s\n", b->base->toChars());
-
-
-
+
+
-        return;
+        //throw new DeferException(loc, "forward reference of interface %s", baseClass->toChars());
-        }
-    }
-    i++;
@@ -1142 +1139 @@
-    s->addMember(sc, this, 1);
-    }
-
+case 2:
-    sc = sc->push(this);
-    sc->parent = this;
-    if (isCOMinterface())
@@ -1149 +1147 @@
-    sc->structalign = 8;
-    structalign = sc->structalign;
-    sc->offset = 2*PTRSIZE;
+    if (sc_offset >= 0)
+    sc->offset = sc_offset;
+
-    inuse++;
-
-
-
-
+
+
+
+
+
+
+
+
+
-    }
+
-    inuse--;
-    //members->print();
-    sc->pop();
-    //printf("-InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type);
+
+    deferState = -1;
+case -1:
+    break;
+default:
+    assert(0 && "deferState for interfaces must be between -1 and 2");
+} // switch for deferStatus
-}
-
-

a/dmd/declaration.c

@@ -688 +688 @@
-    int inferred = 0;
-    if (!type)
-    {   inuse++;
-
+
+
+
+
+
+
-    inuse--;
-    inferred = 1;
-
@@ -1009 +1014 @@
-        Expression *e;
-        Initializer *i2 = init;
-        inuse++;
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-        inuse--;
-        global.gag--;

a/dmd/dsymbol.c

@@ -644 +644 @@
-    symtab = NULL;
-    imports = NULL;
-    prots = NULL;
+    member_semantic_started = false;
-}
-
-ScopeDsymbol::ScopeDsymbol(Identifier *id)
@@ -653 +654 @@
-    symtab = NULL;
-    imports = NULL;
-    prots = NULL;
+    member_semantic_started = false;
-}
-
-Dsymbol *ScopeDsymbol::syntaxCopy(Dsymbol *s)
@@ -765 +767 @@
-        }
-        }
-    }
-
-
-
+
+
+
+
+
+
+
+
+
+
-    }
-}
-
@@ -833 +842 @@
-const char *ScopeDsymbol::kind()
-{
-    return "ScopeDsymbol";
+}
+
+// shares code with AttribDeclaration::callSemanticOnMembers
+void ScopeDsymbol::callSemanticOnMembers(Scope* sc)
+{
+    // first add everything to remaining_semantic
+    if (!member_semantic_started) {
+    for (int i = 0; i < members->dim; i++)
+        remaining_semantic.push_back( (Dsymbol*)members->data[i] );
+    member_semantic_started = true;
+    }
+
+    int failed = 0;
+
+    // last defer exception that was caught. stored for the error message inside
+    DeferException* lastdefer;
+
+    // if we deferred an order dependent member, save it here
+    // we will then skip all order dependent members until this is reached again
+    Dsymbol *deferredOrderDependent = NULL;
+
+    while (!remaining_semantic.empty() && failed != remaining_semantic.size())
+    {   Dsymbol *s;
+    s = remaining_semantic[0];
+    remaining_semantic.pop_front();
+
+    // if we deferred something order dependent, skip other
+    // order dependent ones for one iteration
+    if (deferredOrderDependent == s)
+        deferredOrderDependent = NULL;
+    if (deferredOrderDependent && !isMemberReorderable(s)) {
+        ++failed;
+        remaining_semantic.push_back(s);
+        continue;
+    }
+
+    try {
+        s->semantic(sc);
+    } catch (DeferException* deferexc) {
+        lastdefer = deferexc;
+        ++failed;
+        remaining_semantic.push_back(s);
+        if (!isMemberReorderable(s))
+        deferredOrderDependent = s;
+        continue;
+    }
+
+    failed = 0;
+    postMemberSemantic(sc);
+    }
+
+    if (!remaining_semantic.empty())
+    {
+    assert(lastdefer);
+
+    // reorder members into a valid state if necessary
+    if (deferredOrderDependent)
+        while (remaining_semantic[0] != deferredOrderDependent) {
+        Dsymbol* s = remaining_semantic[0];
+        remaining_semantic.pop_front();
+        remaining_semantic.push_back(s);
+        }
+
+    throw lastdefer;
+    }
-}
-
-
@@ -1002 +1076 @@
-    return NULL;
-}
-
-
-/****************************** DsymbolTable ******************************/
-
-DsymbolTable::DsymbolTable()

a/dmd/dsymbol.h

@@ -20 +20 @@
-
-#include "mars.h"
-#include "arraytypes.h"
+#include <deque>
-
-// llvm
-#include "../ir/irsymbol.h"
@@ -252 +253 @@
-    void emitMemberComments(Scope *sc);
-
-    ScopeDsymbol *isScopeDsymbol() { return this; }
+
+    // LDC
+    std::deque<Dsymbol*> remaining_semantic; // Dsymbols where semantic remains to be called
+    bool member_semantic_started;
+    void callSemanticOnMembers(Scope* sc);
+    virtual void postMemberSemantic(Scope* sc) {}
+    virtual bool isMemberReorderable(Dsymbol* sym) { return true; }
-};
-
-// With statement scope

a/dmd/func.c

@@ -327 +327 @@
-        break;
-
-        case -2:    // can't determine because of fwd refs
-
-
+
-
-        default:
-        {   FuncDeclaration *fdv = (FuncDeclaration *)cd->vtbl.data[vi];
@@ -401 +400 @@
-            break;
-
-        case -2:
-
-
+
-
-        default:
-        {   FuncDeclaration *fdv = (FuncDeclaration *)b->base->vtbl.data[vi];
@@ -497 +495 @@
-            }
-            if (cov == 3)
-            {
-
-
+
-            }
-        }
-        }

a/dmd/import.c

@@ -121 +121 @@
-{
-    //printf("Import::semantic('%s')\n", toChars());
-
-
+
+
+
+
+
+
-
-    if (mod)
-    {
@@ -137 +142 @@
-
-    // Modules need a list of each imported module
-    //printf("%s imports %s\n", sc->module->toChars(), mod->toChars());
-
+
+
+
+
+
+
-
-    mod->semantic();
-
@@ -168 +178 @@
-    }
-    sc = sc->pop();
-    }
+
+    if (defer)
+    throw defer;
-    //printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
-}
-

a/dmd/mars.c

@@ -1154 +1154 @@
-    m = (Module *)modules.data[i];
-    if (global.params.verbose)
-        printf("semantic  %s\n", m->toChars());
-
+
+
+
+
+
-    }
-    if (global.errors)
-    fatal();

a/dmd/module.c

@@ -50 +50 @@
-DsymbolTable *Module::modules;
-Array Module::amodules;
-
-Array
+std::deque<DeferredDsymbol>
-unsigned Module::dprogress;
-
-void Module::init()
@@ -130 +130 @@
-    llvmForceLogging = false;
-    this->doDocComment = doDocComment;
-    this->doHdrGen = doHdrGen;
+    sc = NULL;
-}
-
-File* Module::buildFilePath(char* forcename, char* path, char* ext)
@@ -620 +621 @@
-void Module::semantic(Scope* unused_sc)
-{   int i;
-
-
+
+
-    return;
-
-
-
+
+
+
+
-
-    
-    
-    
-    Scope *
+   
+   
+   
+   
-
-    
+   
-
-    
-    
-    
-
-
-    
+   
+   
+   
+    
+    
+   
-
-    
-    
-    
-    
+   
+   
+   
+   
-
-
-
+
+
+
-    }
-
-    // Pass 1 semantic routines: do public side of the definition
-
-
-
-
-
-
-
+
+
+
+
+
-    }
-
-    sc = sc->pop();
-    sc->pop();
-
+
+
-    //printf("-Module::semantic(this = %p, '%s'): parent = %p\n", this, toChars(), parent);
-}
-
-void Module::semantic2(Scope* unused_sc)
-{   int i;
-
-deferred.dim
+!deferred.empty()
-    {
-dim
+size()
-    {
-(Dsymbol *)deferred.data[i]
+deferred[i].sym
-
-        sd->error("unable to resolve forward reference in definition");
-    }
@@ -814 +818 @@
-    s = ScopeDsymbol::search(loc, ident, flags);
-    insearch = 0;
-
+    if (!s && semanticstarted == -1)
+        error("Forward reference!");
+
-    searchCacheIdent = ident;
-    searchCacheSymbol = s;
-    searchCacheFlags = flags;
@@ -825 +832 @@
- * Can't run semantic on s now, try again later.
- */
-
-
+ym, Scope *scope
-{
-    // Don't add it if it is already there
-dim
+size()
-    {
-.data[i]
+[i].sym
-
-
+ym
-        return;
-    }
-
+    // copy scope
+    Scope* scx = new Scope(*scope);
+    scx->setNoFree();
+
-    //printf("Module::addDeferredSemantic('%s')\n", s->toChars());
-(s
+_back(DeferredDsymbol(sym, scx)
-}
-
-
@@ -847 +858 @@
-
-void Module::runDeferredSemantic()
-{
-size_t len
+//if (deferred.dim) printf("+Module::runDeferredSemantic('%s'), len = %d\n", toChars(), deferred.dim)
-
-    static int nested;
-    if (nested)
-    return;
-    //if (deferred.dim) printf("+Module::runDeferredSemantic('%s'), len = %d\n", toChars(), deferred.dim);
-    nested++;
-
-
-
-
-
-
-
+
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-
+
-
-    for (int i = 0; i < len; i++)
-    {
-        Dsymbol *s = todo[i];
-
-        s->semantic(NULL);
-        //printf("deferred: %s, parent = %s\n", s->toChars(), s->parent->toChars());
-    }
-    //printf("\tdeferred.dim = %d, len = %d, dprogress = %d\n", deferred.dim, len, dprogress);
-    } while (deferred.dim < len || dprogress);  // while making progress
-    nested--;
-    //printf("-Module::runDeferredSemantic('%s'), len = %d\n", toChars(), deferred.dim);
-}

a/dmd/module.h

@@ -17 +17 @@
-
-#include "root.h"
-#include "dsymbol.h"
+#include <deque>
-
-struct ModuleInfoDeclaration;
-struct ClassDeclaration;
@@ -38 +39 @@
-#endif
-#endif
-
+// The global list of out-of-order deferred Dsymbols
+// contains elements of this type. In addition to the
+// Dsymbol, they hold the scope that's to be used for
+// the deferred semantic call.
+struct DeferredDsymbol
+{
+    DeferredDsymbol(Dsymbol* sym_, Scope* scope_)
+    : sym(sym_), scope(scope_) {}
+
+    Dsymbol* sym;
+    Scope* scope;
+};
+
-struct Package : ScopeDsymbol
-{
-    Package(Identifier *ident);
@@ -55 +69 @@
-    static Module *rootModule;
-    static DsymbolTable *modules;   // symbol table of all modules
-    static Array amodules;      // array of all modules
-Array
+std::deque<DeferredDsymbol>
-    static unsigned dprogress;  // progress resolving the deferred list
-    static void init();
-
@@ -139 +153 @@
-    int needModuleInfo();
-    Dsymbol *search(Loc loc, Identifier *ident, int flags);
-    void deleteObjFile();
-
+ym, Scope* scope
-    void runDeferredSemantic();
-    int imports(Module *m);
-
@@ -179 +193 @@
-
-    // array ops emitted in this module already
-    StringTable arrayfuncs;
+
+    // LDC
+    virtual void postMemberSemantic(Scope* sc) { runDeferredSemantic(); }
+    Scope* sc;
-};
-
-

a/dmd/mtype.c

@@ -3960 +3960 @@
-#ifdef DEBUG
-    printf("2: ");
-#endif
-
+
+
-    return tint32;
-    }
-    return sym->memtype->toBasetype();
@@ -4645 +4646 @@
-Type *TypeClass::semantic(Loc loc, Scope *sc)
-{
-    //printf("TypeClass::semantic(%s)\n", sym->toChars());
-    if (sym->scope)
-    sym->semantic(sym->scope);
-    return merge();
-}
-

a/dmd/root.c

@@ -148 +148 @@
-    exit(EXIT_FAILURE);
-}
-#endif
+
+DeferException::DeferException(Loc& loc, const char* format, ...)
+{
+    errormessage = (char *)mem.malloc(200);
+    va_list ap;
+
+    va_start(ap, format);
+    size_t n = snprintf(errormessage, 200, "%s: ", loc.toChars());
+    vsnprintf(errormessage+n, 200-n, format, ap);
+    va_end( ap );
+
+    //warning("Avoided a forward reference error:\n  %s\n  This might not be safe. If you run into issues, this may be the cause!", errormessage);
+}
-
-void error_mem()
-{

a/dmd/root.h

@@ -32 +32 @@
-void error(const char *format, ...);
-void error(const wchar_t *format, ...);
-void warning(const char *format, ...);
+
+struct Loc;
+
+// Thrown when deferring the current Dsymbol is desired.
+// Hopes to eventually transfer control to 
+// ScopeDsymbol/AnonDecl::callSemanticOnMembers, which will
+// reschedule the Dsymbol to have semantic() run after other
+// members have completed theirs.
+struct DeferException
+{
+    char* errormessage;
+    DeferException(Loc& loc, const char* format, ...);
+};
-
-#ifndef TYPEDEFS
-#define TYPEDEFS

a/dmd/struct.c

@@ -43 +43 @@
-
-    stag = NULL;
-    sinit = NULL;
-
+
+
-}
-
-enum PROT AggregateDeclaration::prot()
@@ -54 +55 @@
-void AggregateDeclaration::semantic2(Scope *sc)
-{
-    //printf("AggregateDeclaration::semantic2(%s)\n", toChars());
-    if (scope)
-    {   error("has forward references");
-    return;
-    }
-    if (members)
-    {
-    sc = sc->push(this);
@@ -171 +168 @@
-
-    if (ts->sym->sizeok != 1)
-    {
-        // cannot finish; flag as forward referenced
-return
+
+throw new DeferException(v->loc, "forward reference to struct %s", v->toChars())
-    }
-    }
-    if (t->ty == Tident)
-    {
-        // cannot finish; flag as forward referenced
-return
+
+throw new DeferException(v->loc, "forward reference to %s", v->toChars())
-    }
-
-    memsize = v->type->size(loc);
@@ -210 +207 @@
-
-    // For forward references
-    type = new TypeStruct(this);
+
+    // LDC
+    deferState = 0;
-}
-
-Dsymbol *StructDeclaration::syntaxCopy(Dsymbol *s)
@@ -227 +227 @@
-void StructDeclaration::semantic(Scope *sc)
-{   int i;
-    Scope *sc2;
-
+
+
-    //printf("+StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
-
-    //static int count; if (++count == 20) *(char*)0=0;
-
+int continueAt = deferState;
+if (deferState > 0)
+    deferState = 0;
+switch (continueAt) {
+case 0:
-    assert(type);
-    if (!members)           // if forward reference
-    return;
-
-    if (symtab)
-   if (!scope)
-            
+
+   
-    }
-    else
-        symtab = new DsymbolTable();
-
-    Scope *scx = NULL;
-    if (scope)
-    {   sc = scope;
-        scx = scope;            // save so we don't make redundant copies
-        scope = NULL;
-    }
-
-    parent = sc->parent;
-    handle = type->pointerTo();
@@ -270 +269 @@
-    }
-    }
-
+case 1:
-    sizeok = 0;
-    sc2 = sc->push(this);
-    sc2->stc = 0;
@@ -279 +279 @@
-    sc2->protection = PROTpublic;
-    sc2->explicitProtection = 0;
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
+
+
-    }
-
-    /* The TypeInfo_Struct is expecting an opEquals and opCmp with
-     * a parameter that is a pointer to the struct. But if there
-     * isn't one, but is an opEquals or opCmp with a value, write
@@ -321 +322 @@
-    tfeq = (TypeFunction *)tfeq->semantic(0, sc);
-    }
-
-Identifier *
-nt i
+
+
-    {
-    Dsymbol *s = search_function(this, id);
-    FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
@@ -354 +355 @@
-
-
-    sc2->pop();
-
-    if (sizeok == 2)
-    {   // semantic() failed because of forward references.
-    // Unwind what we did, and defer it for later
-    fields.setDim(0);
-    structsize = 0;
-    alignsize = 0;
-    structalign = 0;
-
-    scope = scx ? scx : new Scope(*sc);
-    scope->setNoFree();
-    scope->module->addDeferredSemantic(this);
-    //printf("\tdeferring %s\n", toChars());
-    return;
-    }
-
-    // 0 sized struct's are set to 1 byte
-    if (structsize == 0)
@@ -423 +409 @@
-    semantic2(sc);
-    semantic3(sc);
-    }
+    deferState = -1;
+case -1:
+    break;
+default:
+    assert(0 && "deferState for structs must be between -1 and 1");
+} // switch for deferring
-}
-
-void StructDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
@@ -457 +449 @@
-    return "struct";
-}
-
+Dsymbol *StructDeclaration::search(Loc loc, Identifier *ident, int flags)
+{
+    Dsymbol *s;
+
+    //printf("%s.StructDeclaration::search('%s')\n", toChars(), ident->toChars());
+
+    s = ScopeDsymbol::search(loc, ident, flags);
+
+    if (!s && (!members || !symtab || deferState > 0))
+    {
+    throw new DeferException(loc, "%s is forward referenced when looking for '%s'", toChars(), ident->toChars());
+    }
+    return s;
+}
+
+bool StructDeclaration::isMemberReorderable(Dsymbol* s)
+{
+    if (
+    s->isVarDeclaration() ||
+    s->isAttribDeclaration()
+    )
+    return false;
+    return true;
+}
+
-/********************************* UnionDeclaration ****************************/
-
-UnionDeclaration::UnionDeclaration(Loc loc, Identifier *id)
@@ -482 +499 @@
-    return "union";
-}
-
-
+
+
+
+

a/dmd/template.c

@@ -2877 +2877 @@
-    // LDC
-    this->tinst = NULL;
-    this->tmodule = NULL;
+    this->deferState = 0;
-}
-
-/*****************
@@ -2908 +2909 @@
-    // LDC
-    this->tinst = NULL;
-    this->tmodule = NULL;
+    this->deferState = 0;
-
-    assert((size_t)tempdecl->scope > 0x10000);
-}
@@ -2953 +2955 @@
-
-void TemplateInstance::semantic(Scope *sc)
-{
+    int memnum = 0;
+    int dosemantic3 = 0;
+    unsigned errorsave;
+    int tempdecl_instance_idx;
+
+int continueAt = deferState;
+if (deferState > 0)
+    deferState = 0;
+switch (continueAt) {
+case 0:
-    if (global.errors)
-    {
-    if (!global.gag)
@@ -3016 +3028 @@
-    semanticTiargs(sc);
-
-    tempdecl = findTemplateDeclaration(sc);
-
-
+
+
+
+
+
+
+
+
-    if (!tempdecl || global.errors)
-    {   inst = this;
-        //printf("error return %p, %d\n", tempdecl, global.errors);
@@ -3070 +3088 @@
-#if LOG
-    printf("\timplement template instance '%s'\n", toChars());
-#endif
-unsigned 
+
-    inst = this;
-int 
+
-    tempdecl->instances.push(this);
-    parent = tempdecl->parent;
-    //printf("parent = '%s'\n", parent->kind());
@@ -3088 +3106 @@
-    // Add 'this' to the enclosing scope's members[] so the semantic routines
-    // will get called on the instance members
-#if 1
-    int dosemantic3 = 0;
-    {   Array *a;
-
-    Scope *scx = sc;
@@ -3134 +3151 @@
-    // Copy the syntax trees from the TemplateDeclaration
-    members = Dsymbol::arraySyntaxCopy(tempdecl->members);
-
+case 1:
+    semanticdone = 1;
-    // Create our own scope for the template parameters
-Scope *
+
-    if (!scope)
-    {
-
-
+
+
+
-    }
-
-#if LOG
@@ -3155 +3175 @@
-    // Add members of template instance to template instance symbol table
-//    parent = scope->scopesym;
-    symtab = new DsymbolTable();
-    int memnum = 0;
-    for (int i = 0; i < members->dim; i++)
-    {
-    Dsymbol *s = (Dsymbol *)members->data[i];
@@ -3193 +3212 @@
-#if LOG
-    printf("\tdo semantic() on template instance members '%s'\n", toChars());
-#endif
-    Scope *sc2;
-    sc2 = scope->push(this);
-    //printf("isnested = %d, sc->parent = %s\n", isnested, sc->parent->toChars());
-    sc2->parent = /*isnested ? sc->parent :*/ this;
-    sc2->tinst = this;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-    /* If any of the instantiation members didn't get semantic() run
-     * on them due to forward references, we cannot run semantic2()
-     * or semantic3() yet.
-     */
-dim
-.data[i]
+size()
+[i].sym
-
-    if (sd->parent == this)
-        goto Laftersemantic;
@@ -3276 +3274 @@
-#if LOG
-    printf("-TemplateInstance::semantic('%s', this=%p)\n", toChars(), this);
-#endif
+
+    deferState = -1;
+case -1:
+    break;
+default:
+    assert(0 && "deferState for template instances must be between -1 and 2");
+} // switch for deferring
-}
-
-
@@ -3521 +3526 @@
-    dedtypes.zero();
-    if (!td->scope)
-    {
-
-
+
-    }
-    m = td->matchWithInstance(this, &dedtypes, 0);
-    //printf("matchWithInstance = %d\n", m);
@@ -4012 +4016 @@
-    }
-}
-
+void TemplateInstance::postMemberSemantic(Scope *sc)
+{
+    sc->module->runDeferredSemantic();
+}
+
-/* ======================== TemplateMixin ================================ */
-
-TemplateMixin::TemplateMixin(Loc loc, Identifier *ident, Type *tqual,
@@ -4024 +4033 @@
-    this->idents = idents;
-    this->tiargs = tiargs ? tiargs : new Objects();
-    this->scope = NULL;
+    this->deferState = 0;
-}
-
-Dsymbol *TemplateMixin::syntaxCopy(Dsymbol *s)
@@ -4053 +4063 @@
-
-void TemplateMixin::semantic(Scope *sc)
-{
+    unsigned errorsave;
+
+int continueAt = deferState;
+if (deferState > 0)
+    deferState = 0;
+switch (continueAt) {
+case 0:
+
-#if LOG
-    printf("+TemplateMixin::semantic('%s', this=%p)\n", toChars(), this);
-    fflush(stdout);
@@ -4078 +4096 @@
-    util_progress();
-#endif
-
-Scope *
+
-    if (scope)
-    {   sc = scope;
-    scx = scope;        // save so we don't make redundant copies
@@ -4153 +4171 @@
-         */
-        semanticdone = 0;
-        AggregateDeclaration *ad = toParent()->isAggregateDeclaration();
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-    }
-    }
-
@@ -4251 +4265 @@
-#if LOG
-    printf("\tcreate scope for template parameters '%s'\n", toChars());
-#endif
-Scope *
+
-    scy = sc->push(this);
-    scy->parent = this;
-
-    argsym = new ScopeDsymbol();
-    argsym->parent = scy->parent;
-Scope *
-
-unsigned 
+
+
+
-
-    // Declare each template parameter as an alias for the argument type
-    declareParameters(scope);
@@ -4279 +4293 @@
-#if LOG
-    printf("\tdo semantic() on template instance members '%s'\n", toChars());
-#endif
-    Scope *sc2;
-    sc2 = scope->push(this);
-    sc2->offset = sc->offset;
-
-
-
-
+
+
+
+
+
+
+
+
-    }
-    sc->offset = sc2->offset;
+
+    /* If any of the instantiation members didn't get semantic() run
+     * on them due to forward references, error!
+     */
+    for (size_t i = 0; i < Module::deferred.size(); i++)
+    {   Dsymbol *sd = (Dsymbol *)Module::deferred[i].sym;
+
+    if (sd->parent == this)
+        error("semantic failed due to forward references in %s", sd->toPrettyChars());
+    }
-
-    /* The problem is when to parse the initializer for a variable.
-     * Perhaps VarDeclaration::semantic() should do it like it does
@@ -4319 +4346 @@
-#if LOG
-    printf("-TemplateMixin::semantic('%s', this=%p)\n", toChars(), this);
-#endif
+
+    deferState = -1;
+case -1:
+    break;
+default:
+    assert(0 && "deferState for template mixins must be between -1 and 1");
+} // switch for deferring
-}
-
-void TemplateMixin::semantic2(Scope *sc)

a/dmd/template.h

@@ -328 +328 @@
-    TemplateInstance *tinst; // enclosing template instance
-    Module* tmodule; // module from outermost enclosing template instantiation
-    void printInstantiationTrace();
+
+    void postMemberSemantic(Scope* sc);
+    int deferState;
+    Scope *sc2;
+    Scope *scope;
-};
-
-struct TemplateMixin : TemplateInstance
@@ -353 +358 @@
-    void toObjFile(int multiobj);           // compile to .obj file
-
-    TemplateMixin *isTemplateMixin() { return this; }
+
+    // LDC
+    int deferState;
+    Scope *sc2, *scy, *scx;
-};
-
-Expression *isExpression(Object *o);