Changeset 4520b77e for src/Validate

Timestamp:

Sep 20, 2022, 8:37:05 PM (19 months ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

a065f1f

Parents:

d489da8 (diff), 12df6fe (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 to Master Sept 19

Location:

src/Validate

Files:

• Autogen.cpp (modified) (1 diff)
• FixQualifiedTypes.cpp (modified) (2 diffs)
• LinkReferenceToTypes.cpp (modified) (2 diffs)
• ReplaceTypedef.cpp (modified) (1 diff)

src/Validate/Autogen.cpp

@@ -235 +235 @@
         // Must visit children (enum constants) to add them to the symbol table.
         if ( !enumDecl->body ) return;
+
+        // if ( auto enumBaseType = enumDecl->base ) {
+        //      if ( auto enumBaseTypeAsStructInst = dynamic_cast<const ast::StructInstType *>(enumBaseType.get()) ) {
+        //              const ast::StructDecl * structDecl = enumBaseTypeAsStructInst->base.get();
+        //              this->previsit( structDecl );
+        //      }
+        // }
 
         ast::EnumInstType enumInst( enumDecl->name );

src/Validate/FixQualifiedTypes.cpp

@@ -19 +19 @@
 #include "AST/TranslationUnit.hpp"
 #include "Validate/NoIdSymbolTable.hpp"
+#include "SymTab/Mangler.h"            // for Mangler
+#include "AST/LinkageSpec.hpp"                     // for Linkage
 
 namespace Validate {
@@ -89 +91 @@
                 }
         }
+
+        ast::Expr const * postvisit( ast::QualifiedNameExpr const * t) {
+                assert( location );
+                if ( t->type_decl ) {
+                auto enumName = t->type_decl->name;
+                const ast::EnumDecl * enumDecl = symtab.lookupEnum( enumName );
+                        for ( ast::ptr<ast::Decl> const & member : enumDecl->members ) {
+                                if ( auto memberAsObj = member.as<ast::ObjectDecl>() ) {
+                                        if ( memberAsObj->name == t->name ) {
+                                                return new ast::VariableExpr( t->location, memberAsObj );
+                                        }
+                                } else {
+                                        assertf( false, "unhandled qualified child type");
+                                }
+                        }
+
+
+                auto var = new ast::ObjectDecl( t->var->location, t->name,
+                         new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
+                        var->scopeLevel = 1; // 1 for now; should copy the scopeLevel of the enumValue
+                        var->mangleName = Mangle::mangle( var );
+                        return new ast::VariableExpr( t->location, var );
+                // return ret;
+        }
+
+                return t;
+        }
+
 };
 

src/Validate/LinkReferenceToTypes.cpp

@@ -46 +46 @@
         void postvisit( ast::UnionDecl const * decl );
         ast::TraitDecl const * postvisit( ast::TraitDecl const * decl );
+        ast::QualifiedNameExpr const * previsit( ast::QualifiedNameExpr const * decl);
 
 private:
@@ -292 +293 @@
 }
 
+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
 

src/Validate/ReplaceTypedef.cpp

@@ -183 +183 @@
         } else if ( auto enumType = dynamic_cast<ast::EnumInstType const *>( designatorType ) ) {
                 declsToAddBefore.push_back( new ast::EnumDecl(
-                        decl->location, enumType->name, {}, decl->linkage,
+                        decl->location, enumType->name, false, {}, decl->linkage,
                         ( (enumType->base) ? enumType->base->base : nullptr )
                         ) );