Changeset 2a301ff for src/Validate/LinkReferenceToTypes.cpp

Timestamp:

Aug 31, 2023, 11:31:15 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

950c58e

Parents:

92355883 (diff), 686912c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Resolve conflict

File:

• src/Validate/LinkReferenceToTypes.cpp (modified) (9 diffs)

src/Validate/LinkReferenceToTypes.cpp

@@ -10 +10 @@
 // Created On       : Thr Apr 21 11:41:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Sep 20 16:17:00 2022
-// Update Count     : 2
+// Last Modified On : Fri Jul 14  9:19:00 2023
+// Update Count     : 3
 //
 
@@ -27 +27 @@
 struct LinkTypesCore : public WithNoIdSymbolTable,
                 public ast::WithCodeLocation,
+                public ast::WithDeclsToAdd<>,
                 public ast::WithGuards,
                 public ast::WithShortCircuiting,
@@ -63 +64 @@
         template<typename AggrDecl>
         AggrDecl const * renameGenericParams( AggrDecl const * decl );
+
+        // This cluster is used to add declarations (before) but outside of
+        // any "namespaces" which would qualify the names.
+        bool inNamespace = false;
+        std::list<ast::ptr<ast::Decl>> declsToAddOutside;
+        /// The "leaveNamespace" is handled by guard.
+        void enterNamespace();
+        /// Puts the decl on the back of declsToAddAfter once traversal is
+        /// outside of any namespaces.
+        void addDeclAfterOutside( ast::Decl const * );
 };
+
+void LinkTypesCore::enterNamespace() {
+        if ( inNamespace ) return;
+        inNamespace = true;
+        GuardAction( [this](){
+                inNamespace = false;
+                declsToAddAfter.splice( declsToAddAfter.begin(), declsToAddOutside );
+        } );
+}
+
+void LinkTypesCore::addDeclAfterOutside( ast::Decl const * decl ) {
+        if ( inNamespace ) {
+                declsToAddOutside.emplace_back( decl );
+        } else {
+                declsToAddAfter.emplace_back( decl );
+        }
+}
 
 ast::TypeInstType const * LinkTypesCore::postvisit( ast::TypeInstType const * type ) {
@@ -81 +109 @@
         ast::EnumDecl const * decl = symtab.lookupEnum( type->name );
         // It's not a semantic error if the enum is not found, just an implicit forward declaration.
-        if ( decl ) {
-                // Just linking in the node.
-                auto mut = ast::mutate( type );
-                mut->base = decl;
-                type = mut;
-        }
-        if ( !decl || !decl->body ) {
-                auto mut = ast::mutate( type );
+        // The unset code location is used to detect imaginary declarations.
+        // (They may never be used for enumerations.)
+        if ( !decl || decl->location.isUnset() ) {
+                assert( location );
+                ast::EnumDecl * mut = new ast::EnumDecl( *location, type->name );
+                mut->linkage = ast::Linkage::Compiler;
+                decl = mut;
+                symtab.addEnum( decl );
+                addDeclAfterOutside( decl );
+        }
+
+        ast::EnumInstType * mut = ast::mutate( type );
+
+        // Just linking in the node.
+        mut->base = decl;
+
+        if ( !decl->body ) {
                 forwardEnums[ mut->name ].push_back( mut );
-                type = mut;
-        }
-        return type;
+        }
+        return mut;
 }
 
@@ -98 +134 @@
         ast::StructDecl const * decl = symtab.lookupStruct( type->name );
         // It's not a semantic error if the struct is not found, just an implicit forward declaration.
-        if ( decl ) {
-                // Just linking in the node.
-                auto mut = ast::mutate( type );
-                mut->base = decl;
-                type = mut;
-        }
-        if ( !decl || !decl->body ) {
-                auto mut = ast::mutate( type );
+        // The unset code location is used to detect imaginary declarations.
+        if ( !decl || decl->location.isUnset() ) {
+                assert( location );
+                ast::StructDecl * mut = new ast::StructDecl( *location, type->name );
+                mut->linkage = ast::Linkage::Compiler;
+                decl = mut;
+                symtab.addStruct( decl );
+                addDeclAfterOutside( decl );
+        }
+
+        ast::StructInstType * mut = ast::mutate( type );
+
+        // Just linking in the node.
+        mut->base = decl;
+
+        if ( !decl->body ) {
                 forwardStructs[ mut->name ].push_back( mut );
-                type = mut;
-        }
-        return type;
+        }
+        return mut;
 }
 
@@ -115 +158 @@
         ast::UnionDecl const * decl = symtab.lookupUnion( type->name );
         // It's not a semantic error if the union is not found, just an implicit forward declaration.
-        if ( decl ) {
-                // Just linking in the node.
-                auto mut = ast::mutate( type );
-                mut->base = decl;
-                type = mut;
-        }
-        if ( !decl || !decl->body ) {
-                auto mut = ast::mutate( type );
+        // The unset code location is used to detect imaginary declarations.
+        if ( !decl || decl->location.isUnset() ) {
+                assert( location );
+                ast::UnionDecl * mut = new ast::UnionDecl( *location, type->name );
+                mut->linkage = ast::Linkage::Compiler;
+                decl = mut;
+                symtab.addUnion( decl );
+                addDeclAfterOutside( decl );
+        }
+
+        ast::UnionInstType * mut = ast::mutate( type );
+
+        // Just linking in the node.
+        mut->base = decl;
+
+        if ( !decl->body ) {
                 forwardUnions[ mut->name ].push_back( mut );
-                type = mut;
-        }
-        return type;
+        }
+        return mut;
 }
 
@@ -228 +278 @@
 
 ast::StructDecl const * LinkTypesCore::previsit( ast::StructDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }
@@ -246 +297 @@
 
 ast::UnionDecl const * LinkTypesCore::previsit( ast::UnionDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }
@@ -264 +316 @@
 
 ast::TraitDecl const * LinkTypesCore::postvisit( ast::TraitDecl const * decl ) {
-        auto mut = ast::mutate( decl );
-        if ( mut->name == "sized" ) {
-                // "sized" is a special trait - flick the sized status on for the type variable.
-                assertf( mut->params.size() == 1, "Built-in trait 'sized' has incorrect number of parameters: %zd", decl->params.size() );
-                ast::TypeDecl * td = mut->params.front().get_and_mutate();
-                td->sized = true;
-        }
-
         // There is some overlap with code from decayForallPointers,
         // perhaps reorganization or shared helper functions are called for.
         // Move assertions from type parameters into the body of the trait.
+        auto mut = ast::mutate( decl );
         for ( ast::ptr<ast::TypeDecl> const & td : decl->params ) {
                 auto expanded = expandAssertions( td->assertions );