Changeset 5408b59

Timestamp:

Oct 18, 2022, 9:12:19 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master

Children:

c2b3243

Parents:

1e30df7

Message:

Remove var in QualifiedNameExpr?

Location:

src

Files:

• AST/Convert.cpp (modified) (4 diffs)
• AST/Decl.hpp (modified) (1 diff)
• AST/Expr.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (3 diffs)
• Parser/ExpressionNode.cc (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• SymTab/Mangler.cc (modified) (4 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SymTab/ValidateType.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• Validate/FixQualifiedTypes.cpp (modified) (1 diff)
• Validate/LinkReferenceToTypes.cpp (modified) (2 diffs)

src/AST/Convert.cpp ¶

@@ -310 +310 @@
                         node->name,
                         get<Attribute>().acceptL( node->attributes ),
-                        false, // Temporary
+                        node->isTyped,
                         LinkageSpec::Spec( node->linkage.val ),
                         get<Type>().accept1(node->base)
                 );
-                return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble
+                return aggregatePostamble( decl, node );
         }
 
@@ -737 +737 @@
                                 node->name
                 );
-                temp->var = get<DeclarationWithType>().accept1(node->var);
                 auto expr = visitBaseExpr( node,
                         temp
@@ -2282 +2281 @@
         }
 
-        /// xxx - type_decl should be DeclWithType in the final design
-        /// type_decl is set to EnumDecl as a temporary fix
         virtual void visit( const QualifiedNameExpr * old ) override final {
                 this->node = visitBaseExpr( old,
@@ -2289 +2286 @@
                                 old->location,
                                 GET_ACCEPT_1(type_decl, Decl),
-                                GET_ACCEPT_1(var, DeclWithType),
                                 old->name
                         )

src/AST/Decl.hpp ¶

@@ -315 +315 @@
 class EnumDecl final : public AggregateDecl {
 public:
-        bool isTyped;
-        ptr<Type> base;
+        bool isTyped; // isTyped indicated if the enum has a declaration like:
+        // enum (type_optional) Name {...} 
+        ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
 
         EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false, 

src/AST/Expr.hpp ¶

@@ -257 +257 @@
 public:
         ptr<Decl> type_decl;
-        ptr<DeclWithType> var;
         std::string name;
 
-        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const DeclWithType * r, const std::string & n ) 
-        : Expr( loc ), type_decl( d ), var(r), name( n ) {}
+        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n ) 
+        : Expr( loc ), type_decl( d ), name( n ) {}
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Pass.impl.hpp ¶

@@ -1205 +1205 @@
         if ( __visit_children() ) {
                 guard_symtab guard { *this };
-                maybe_accept( node, &QualifiedNameExpr::var );
                 maybe_accept( node, &QualifiedNameExpr::type_decl );
         }

src/CodeGen/CodeGenerator.cc ¶

@@ -912 +912 @@
                 }
                 output << ")";
-        }
-
-        // QualifiedNameExpr should not reach to CodeGen.
-        // FixQualifiedName Convert QualifiedNameExpr to VariableExpr
-        void CodeGenerator::postvisit( QualifiedNameExpr * expr ) {
-                output << "/* label */" << mangleName(expr->var);
         }
 

src/CodeGen/CodeGenerator.h ¶

@@ -103 +103 @@
                 void postvisit( DefaultArgExpr * );
                 void postvisit( GenericExpr * );
-                void postvisit( QualifiedNameExpr *);
 
                 //*** Statements

src/Common/PassVisitor.impl.h ¶

@@ -1934 +1934 @@
         indexerScopedAccept( node->result, *this );
         maybeAccept_impl( node->type_decl, *this );
-        maybeAccept_impl( node->var, *this );
 
         VISIT_END( node );
@@ -1945 +1944 @@
         indexerScopedAccept( node->result, *this );
         maybeAccept_impl( node->type_decl, *this );
-        maybeAccept_impl( node->var, *this );
 
         VISIT_END( node );
@@ -1957 +1955 @@
     indexerScopedMutate( node->result, *this );
         maybeMutate_impl( node->type_decl, *this );
-        maybeAccept_impl( node->var, *this );
 
         MUTATE_END( Expression, node );

src/Parser/ExpressionNode.cc ¶

@@ -523 +523 @@
                 auto enumInst = new EnumInstType( Type::Qualifiers(), e );
                 auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr );
-                ret->set_var( obj );
         }
         return ret;

src/ResolvExpr/CandidateFinder.cpp ¶

@@ -862 +862 @@
                                 }
                         }
-                }
-
-                void postvisit( const ast::QualifiedNameExpr * qualifiedNameExpr ) {
-                        auto mangleName = Mangle::mangle(qualifiedNameExpr->var);
-                        addCandidate( qualifiedNameExpr, tenv );
                 }
 

src/SymTab/Mangler.cc ¶

@@ -65 +65 @@
                                 void postvisit( const QualifiedType * qualType );
 
-                                void postvisit( const QualifiedNameExpr * qualNameExpr );
-
                                 std::string get_mangleName() { return mangleName; }
                           private:
@@ -307 +305 @@
                                         mangleName += Encoding::qualifiedTypeEnd;
                                 }
-                        }
-
-                        void Mangler_old::postvisit( const QualifiedNameExpr * qual ) {
-                                maybeAccept( qual->var, *visitor );
                         }
 
@@ -423 +417 @@
                         void postvisit( const ast::OneType * oneType );
                         void postvisit( const ast::QualifiedType * qualType );
-                        void postvisit( const ast::QualifiedNameExpr * qualNameExpr );
 
                         std::string get_mangleName() { return mangleName; }
@@ -652 +645 @@
                                 mangleName += Encoding::qualifiedTypeEnd;
                         }
-                }
-                void Mangler_new::postvisit( const ast::QualifiedNameExpr * qual ) {
-                        maybeAccept( qual->var.get(), *visitor );
                 }
 

src/SymTab/Validate.cc ¶

@@ -858 +858 @@
                         declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
                 } else if ( EnumInstType * enumInst = dynamic_cast< EnumInstType * >( designatorType ) ) {
-                        // declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) );
                         if ( enumInst->baseEnum ) {
                                 const EnumDecl * enumDecl = enumInst->baseEnum;

src/SymTab/ValidateType.cc ¶

@@ -81 +81 @@
         void previsit( QualifiedType * qualType );
         void postvisit( QualifiedType * qualType );
-
         void postvisit( QualifiedNameExpr * qualExpr );
-
+        
         void postvisit( EnumDecl * enumDecl );
         void postvisit( StructDecl * structDecl );

src/SynTree/Expression.h ¶

@@ -168 +168 @@
         Declaration * type_decl;
         std::string name;
-        DeclarationWithType * var;
 
         QualifiedNameExpr( Declaration * decl, std::string name): Expression(), type_decl(decl), name(name) {}
-        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name), var(other.var) {}
-        DeclarationWithType * get_var() const { return var; }
-        void set_var( DeclarationWithType * newValue ) { var = newValue; }
+        QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name) {}
 
         virtual ~QualifiedNameExpr() {
-                delete var;
                 delete type_decl;
         }

src/Validate/FixQualifiedTypes.cpp ¶

@@ -102 +102 @@
                         }
 
-
-                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
+                auto var = new ast::ObjectDecl( t->location, t->name,
+                        new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
                         var->mangleName = Mangle::mangle( var );
                         return new ast::VariableExpr( t->location, var );
-                // return ret;
         }
 

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:
@@ -316 +315 @@
 }
 
-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