Changeset a12c81f3 for src

Timestamp:

Jun 28, 2018, 3:29:37 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

c653b37

Parents:

69918cea

git-author:

Rob Schluntz <rschlunt@…> (06/28/18 15:29:31)

git-committer:

Rob Schluntz <rschlunt@…> (06/28/18 15:29:37)

Message:

Replace qualified types with the actual type

File:

• src/SymTab/Validate.cc (modified) (4 diffs)

src/SymTab/Validate.cc

@@ -88 +88 @@
         };
 
+        struct FixQualifiedTypes final : public WithIndexer {
+                Type * postmutate( QualifiedType * );
+        };
+
         struct HoistStruct final : public WithDeclsToAdd, public WithGuards {
                 /// Flattens nested struct types
@@ -282 +286 @@
                 PassVisitor<LabelAddressFixer> labelAddrFixer;
                 PassVisitor<HoistTypeDecls> hoistDecls;
+                PassVisitor<FixQualifiedTypes> fixQual;
 
                 acceptAll( translationUnit, hoistDecls );
@@ -288 +293 @@
                 acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 EliminateTypedef::eliminateTypedef( translationUnit ); //
@@ -341 +347 @@
         void HoistTypeDecls::previsit( UntypedOffsetofExpr * expr ) {
                 handleType( expr->type );
+        }
+
+
+        Type * FixQualifiedTypes::postmutate( QualifiedType * qualType ) {
+                // TODO: change asserts to SemanticErrors as necessary
+                Type * parent = qualType->parent;
+                Type * child = qualType->child;
+                if ( dynamic_cast< GlobalScopeType * >( qualType->parent ) ) {
+                        // .T => lookup T at global scope
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
+                                auto aggr = indexer.globalLookupStruct( inst->name );
+                                return new StructInstType( qualType->get_qualifiers(), aggr );
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
+                                auto aggr =  indexer.globalLookupUnion( inst->name );
+                                return new UnionInstType( qualType->get_qualifiers(), aggr );
+                        } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
+                                auto aggr = indexer.globalLookupEnum( inst->name );
+                                return new EnumInstType( qualType->get_qualifiers(), aggr );
+                        } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
+                                auto td = indexer.globalLookupType( inst->name );
+                                assertf( td, "did not find type at global scope with name: %s", inst->name.c_str() );
+                                auto base = td->base;
+                                if ( base ) return td->base->clone();
+                                assert( false );
+                        } else {
+                                // .T => T is not a SUE type name
+                                assert( false );
+                        }
+                } else {
+                        // S.T => S must be an aggregate type, find the declaration for T in S.
+                        AggregateDecl * aggr = nullptr;
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( parent ) ) {
+                                aggr = inst->baseStruct;
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * > ( parent ) ) {
+                                aggr = inst->baseUnion;
+                        } else {
+                                assert( false );
+                        }
+                        assert( aggr ); // TODO: need to handle forward declarations
+                        for ( Declaration * member : aggr->members ) {
+                                if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
+                                        if ( StructDecl * aggr = dynamic_cast< StructDecl * >( member ) ) {
+                                                if ( aggr->name == inst->name ) {
+                                                        return new StructInstType( qualType->get_qualifiers(), aggr );
+                                                }
+                                        }
+                                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
+                                        if ( UnionDecl * aggr = dynamic_cast< UnionDecl * > ( member ) ) {
+                                                if ( aggr->name == inst->name ) {
+                                                        return new UnionInstType( qualType->get_qualifiers(), aggr );
+                                                }
+                                        }
+                                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
+                                        if ( EnumDecl * aggr = dynamic_cast< EnumDecl * > ( member ) ) {
+                                                if ( aggr->name == inst->name ) {
+                                                        return new EnumInstType( qualType->get_qualifiers(), aggr );
+                                                }
+                                        }
+                                } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
+                                        // struct typedefs are being replaced by forward decls too early; move it to hoist struct
+                                        if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
+                                                if ( aggr->name == inst->name ) {
+                                                        if ( aggr->base ) return aggr->base->clone();
+                                                        assert( false );
+                                                }
+                                        }
+                                } else {
+                                        // S.T - S is not an aggregate => error
+                                        assertf( false, "unhandled qualified child type: %s", toCString(qualType) );
+                                }
+                        }
+                        // failed to find a satisfying definition of type
+                        assertf( false, "failed to find a satisfying definition of %s in %s", toCString(child), toCString(parent) );
+                }
+
+                // ... may want to link canonical SUE definition to each forward decl so that it becomes easier to lookup?
         }