Changeset e874605 for src/Validate

Timestamp:

Oct 28, 2022, 3:11:57 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master

Children:

93d2219

Parents:

77de429

Message:

Add class InlineValueDecl, which is a Declaration class that works as a placeholder for aggregration value inherited from other aggregration. Disable inline value overwrite.

Location:

src/Validate

Files:

• EnumAndPointerDecay.cpp (modified) (3 diffs)
• LinkReferenceToTypes.cpp (modified) (2 diffs)

src/Validate/EnumAndPointerDecay.cpp

@@ -21 +21 @@
 #include "AST/Type.hpp"
 #include "SymTab/FixFunction.h"
+#include "Validate/NoIdSymbolTable.hpp"
 
 namespace Validate {
@@ -26 +27 @@
 namespace {
 
-struct EnumAndPointerDecayCore final : public ast::WithCodeLocation {
+struct EnumAndPointerDecayCore final : public WithNoIdSymbolTable, public ast::WithCodeLocation {
         ast::EnumDecl const * previsit( ast::EnumDecl const * decl );
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
@@ -39 +40 @@
         // Set the type of each member of the enumeration to be EnumContant.
         auto mut = ast::mutate( decl );
-        for ( ast::ptr<ast::Decl> & member : mut->members ) {
-                ast::ObjectDecl const * object = member.strict_as<ast::ObjectDecl>();
-                member = ast::mutate_field( object, &ast::ObjectDecl::type,
-                        new ast::EnumInstType( decl, ast::CV::Const ) );
+        std::vector<ast::ptr<ast::Decl>> buffer;
+        for ( auto it = decl->members.begin(); it != decl->members.end(); ++it ) {
+                if ( ast::ObjectDecl const * object = (*it).as<ast::ObjectDecl>() ) {
+                        buffer.push_back( ast::mutate_field( object, &ast::ObjectDecl::type, new ast::EnumInstType( decl, ast::CV::Const ) ) );
+                } else if ( ast::InlineValueDecl const * value = (*it).as<ast::InlineValueDecl>() ) {
+                        if ( auto targetEnum = symtab.lookupEnum( value->name ) ) {
+                                for ( auto singleMember : targetEnum->members ) {
+                                        auto copyingMember = singleMember.as<ast::ObjectDecl>();
+                                        buffer.push_back( new ast::ObjectDecl(
+                                                value->location, // use the "inline" location
+                                                copyingMember->name,
+                                                new ast::EnumInstType( decl, ast::CV::Const ),
+                                                // Construct a new EnumInstType as the type
+                                                copyingMember->init,
+                                                copyingMember->storage,
+                                                copyingMember->linkage,
+                                                copyingMember->bitfieldWidth,
+                                                {},
+                                                copyingMember->funcSpec
+                                        ) );
+                                }
+                        }
+                }
         }
+        mut->members = buffer;
         return mut;
 }

src/Validate/LinkReferenceToTypes.cpp

@@ -185 +185 @@
                                 decl = mut;
                         }
+                        // visit the base
                 } else if ( auto ptr = decl->base.as<ast::PointerType>() ) {
                         if ( auto base = ptr->base.as<ast::TypeInstType>() ) {
@@ -203 +204 @@
 
         // 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 );