Changeset b0d9ff7 for src/AST

Timestamp:

Sep 1, 2022, 1:27:52 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

12df6fe

Parents:

def751f

Message:

Fix up the QualifiedNameExpr. It should now work on both old AST and new AST. There are some known bugs to fix so make all-tests will fail.

Location:

src/AST

Files:

• Convert.cpp (modified) (4 diffs)
• Decl.hpp (modified) (2 diffs)
• Expr.hpp (modified) (1 diff)
• Fwd.hpp (modified) (1 diff)
• Pass.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (1 diff)
• Print.cpp (modified) (1 diff)
• Visitor.hpp (modified) (1 diff)

src/AST/Convert.cpp

@@ -310 +310 @@
                         node->name,
                         get<Attribute>().acceptL( node->attributes ),
+                        false, // Temporary
                         LinkageSpec::Spec( node->linkage.val ),
                         get<Type>().accept1(node->base)
@@ -731 +732 @@
         }
 
+        const ast::Expr * visit( const ast::QualifiedNameExpr * node ) override final {
+                auto temp = new QualifiedNameExpr(
+                                get<Declaration>().accept1(node->type_decl),
+                                node->name
+                );
+                temp->var = get<DeclarationWithType>().accept1(node->var);
+                auto expr = visitBaseExpr( node,
+                        temp
+                );
+                this->node = expr;
+                return nullptr;
+        }
+
         const ast::Expr * visit( const ast::AddressExpr * node ) override final {
                 auto expr = visitBaseExpr( node,
@@ -1740 +1754 @@
                         old->location,
                         old->name,
+                        old->isTyped,
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->linkage.val },
@@ -2266 +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,
+                        new ast::QualifiedNameExpr (
+                                old->location,
+                                GET_ACCEPT_1(type_decl, Decl),
+                                GET_ACCEPT_1(var, DeclWithType),
+                                old->name
+                        )
+                );
+        }
+
         virtual void visit( const CastExpr * old ) override final {
                 this->node = visitBaseExpr( old,

src/AST/Decl.hpp

@@ -312 +312 @@
 class EnumDecl final : public AggregateDecl {
 public:
+        bool isTyped;
         ptr<Type> base;
 
-        EnumDecl( const CodeLocation& loc, const std::string& name,
-                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall, Type const * base = nullptr,
+        EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false, 
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall,
+                Type const * base = nullptr,
                 std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() )
-        : AggregateDecl( loc, name, std::move(attrs), linkage ), base(base), enumValues(enumValues) {}
+        : AggregateDecl( loc, name, std::move(attrs), linkage ), isTyped(isTyped), base(base), enumValues(enumValues) {}
 
         /// gets the integer value for this enumerator, returning true iff value found
@@ -327 +329 @@
         const char * typeString() const override { return aggrString( Enum ); }
 
-        bool isTyped() {return base && base.get();}
 
 private:

src/AST/Expr.hpp

@@ -254 +254 @@
 };
 
+class QualifiedNameExpr final : public Expr {
+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 ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        QualifiedNameExpr * clone() const override { return new QualifiedNameExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// A reference to a named variable.
 class VariableExpr final : public Expr {

src/AST/Fwd.hpp

@@ -67 +67 @@
 class UntypedExpr;
 class NameExpr;
+class QualifiedNameExpr;
 class AddressExpr;
 class LabelAddressExpr;

src/AST/Pass.hpp

@@ -167 +167 @@
         const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;
         const ast::Expr *             visit( const ast::NameExpr             * ) override final;
+        const ast::Expr *                         visit( const ast::QualifiedNameExpr    * ) override final;
         const ast::Expr *             visit( const ast::AddressExpr          * ) override final;
         const ast::Expr *             visit( const ast::LabelAddressExpr     * ) override final;

src/AST/Pass.impl.hpp

@@ -1193 +1193 @@
 
 //--------------------------------------------------------------------------
+// QualifiedNameExpr
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::QualifiedNameExpr * node ) {
+        VISIT_START( node );
+        if ( __visit_children() ) {
+                guard_symtab guard { *this };
+                maybe_accept( node, &QualifiedNameExpr::var );
+                maybe_accept( node, &QualifiedNameExpr::type_decl );
+        }
+        VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
 // CastExpr
 template< typename core_t >

src/AST/Print.cpp

@@ -899 +899 @@
                 postprint( node );
 
+                return node;
+        }
+
+        virtual const ast::Expr * visit( const ast::QualifiedNameExpr * node ) override final {
+                os << "QualifiedNameExpr: " << std::endl;
+                os << ++indent << "Type: ";
+                safe_print( node->type_decl );
+                os << std::endl;
+                os <<  indent << "Name: " << node->name  << std::endl;
+                --indent;
+                postprint( node );
                 return node;
         }

src/AST/Visitor.hpp

@@ -59 +59 @@
     virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::NameExpr             * ) = 0;
+    virtual const ast::Expr *             visit( const ast::QualifiedNameExpr    * ) = 0;
     virtual const ast::Expr *             visit( const ast::AddressExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::LabelAddressExpr     * ) = 0;