Changeset df6cc9d for src/Validate/LinkReferenceToTypes.cpp

Timestamp:

Oct 19, 2022, 4:43:26 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master

Children:

1a45263

Parents:

9cd5bd2 (diff), 135143ba (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:

Merge branch 'master' into pthread-emulation

File:

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

src/Validate/LinkReferenceToTypes.cpp

@@ -44 +44 @@
         void postvisit( ast::UnionDecl const * decl );
         ast::TraitDecl const * postvisit( ast::TraitDecl const * decl );
-        ast::QualifiedNameExpr const * previsit( ast::QualifiedNameExpr const * decl);
 
 private:
@@ -203 +202 @@
         }
 
+        // The following section 
+        auto mut = ast::mutate( decl );
+        std::vector<ast::ptr<ast::Decl>> buffer;
+        for ( auto it = decl->members.begin(); it != decl->members.end(); ++it) {
+                auto member = (*it).as<ast::ObjectDecl>();
+                if ( member->enumInLine ) {
+                        auto targetEnum = symtab.lookupEnum( member->name );
+                        if ( targetEnum ) {                     
+                                for ( auto singleMamber : targetEnum->members ) {
+                                        auto tm = singleMamber.as<ast::ObjectDecl>();
+                                        auto t = new ast::ObjectDecl(
+                                                member->location, // use the "inline" location
+                                                tm->name,
+                                                new ast::EnumInstType( decl, ast::CV::Const ),
+                                                // Construct a new EnumInstType as the type
+                                                tm->init,
+                                                tm->storage,
+                                                tm->linkage,
+                                                tm->bitfieldWidth,
+                                                {}, // enum member doesn't have attribute
+                                                tm->funcSpec
+                                        );
+                                        t->importValue = true;
+                                        buffer.push_back(t);
+                                }
+                        }
+                } else {
+                        auto search_it = std::find_if( buffer.begin(), buffer.end(), [member](ast::ptr<ast::Decl> cur) {
+                                auto curAsObjDecl = cur.as<ast::ObjectDecl>();
+                                return (curAsObjDecl->importValue) && (curAsObjDecl->name == member->name);
+                        });
+                        if ( search_it != buffer.end() ) {
+                                buffer.erase( search_it ); // Found an import enum value that has the same name
+                                // override the imported value
+                        }
+                        buffer.push_back( *it );
+                }
+        }
+        mut->members = buffer;
+        decl = mut;
+
         ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );
         if ( fwds != forwardEnums.end() ) {
@@ -284 +324 @@
 }
 
-ast::QualifiedNameExpr const * LinkTypesCore::previsit( ast::QualifiedNameExpr const * decl ) {
-        // Try to lookup type
-        if ( auto objDecl = decl->type_decl.as<ast::ObjectDecl>() ) {
-                if ( auto inst = objDecl->type.as<ast::TypeInstType>()) {
-                        if ( auto enumDecl = symtab.lookupEnum ( inst->name ) ) {
-                                auto mut = ast::mutate( decl );
-                                mut->type_decl = enumDecl;
-                                auto enumInst = new ast::EnumInstType( enumDecl );
-                                enumInst->name = decl->name;
-                                // Adding result; addCandidate() use result
-                                mut->result = enumInst;
-                                decl = mut;
-                        }
-                }
-        } else if ( auto enumDecl = decl->type_decl.as<ast::EnumDecl>() ) {
-                auto mut = ast::mutate( decl );
-                auto enumInst = new ast::EnumInstType( enumDecl );
-                enumInst->name = decl->name;
-                // Adding result; addCandidate() use result
-                mut->result = enumInst;
-                decl = mut;
-        }
-        // 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 = const_cast<ast::EnumDecl *>( decl );
-        //      type = mut;
-        // }
-        return decl;
-}
-
 } // namespace