Changeset 63be3387 for src/AST

Timestamp:

Nov 14, 2022, 11:52:44 AM (3 years ago)

Author:

caparson <caparson@…>

Branches:

ADT, ast-experimental, master

Children:

7d9598d8

Parents:

b77f0e1 (diff), 19a8c40 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/AST

Files:

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

src/AST/Convert.cpp

@@ -234 +234 @@
                 }
                 return declWithTypePostamble( decl, node );
+        }
+
+        // InlineMemberDecl vanish after EnumAndPointerDecay pass so no necessary to implement NewToOld
+        const ast::DeclWithType * visit( const ast::InlineMemberDecl * node ) override final {  
+                assert( false );
+                (void) node;
+                return nullptr;
         }
 
@@ -1614 +1621 @@
                         { old->get_funcSpec().val }
                 );
-                decl->enumInLine = old->enumInLine;
                 cache.emplace(old, decl);
                 assert(cache.find( old ) != cache.end());
@@ -1859 +1865 @@
                 decl->uniqueId   = old->uniqueId;
                 decl->storage    = { old->storageClasses.val };
+
+                this->node = decl;
+        }
+
+        virtual void visit( const InlineMemberDecl * old ) override final {
+                if ( inCache( old ) ) {
+                        return;
+                }
+                auto&& type = GET_ACCEPT_1(type, Type);
+                auto&& attr = GET_ACCEPT_V(attributes, Attribute);
+
+                auto decl = new ast::InlineMemberDecl(
+                        old->location,
+                        old->name,
+                        type,
+                        { old->get_storageClasses().val },
+                        { old->linkage.val },
+                        std::move(attr),
+                        { old->get_funcSpec().val }
+                );
+                cache.emplace(old, decl);
+                assert(cache.find( old ) != cache.end());
+                decl->scopeLevel = old->scopeLevel;
+                decl->mangleName = old->mangleName;
+                decl->isDeleted  = old->isDeleted;
+                decl->asmName    = GET_ACCEPT_1(asmName, Expr);
+                decl->uniqueId   = old->uniqueId;
+                decl->extension  = old->extension;
 
                 this->node = decl;

src/AST/Decl.hpp

@@ -105 +105 @@
         ptr<Init> init;
         ptr<Expr> bitfieldWidth;
-        bool enumInLine = false; // enum inline is not a real object declaration. 
-        // It is a place holder for a set of enum value (ObjectDecl)
-        bool importValue = false; // if the value copied from somewhere else
 
         ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type,
@@ -400 +397 @@
 };
 
+/// Static Assertion `_Static_assert( ... , ... );`
 class StaticAssertDecl : public Decl {
 public:
@@ -411 +409 @@
 private:
         StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
+        MUTATE_FRIEND
+};
+
+/// Inline Member Declaration `inline TypeName;`
+class InlineMemberDecl final : public DeclWithType {
+public:
+        ptr<Type> type;
+
+        InlineMemberDecl( const CodeLocation & loc, const std::string & name, const Type * type,
+                Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
+                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ) {}
+
+        const Type * get_type() const override { return type; }
+        void set_type( const Type * ty ) override { type = ty; }
+
+        const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        InlineMemberDecl * clone() const override { return new InlineMemberDecl{ *this }; }
         MUTATE_FRIEND
 };

src/AST/Fwd.hpp

@@ -37 +37 @@
 class DirectiveDecl;
 class StaticAssertDecl;
+class InlineMemberDecl;
 
 class Stmt;

src/AST/Pass.hpp

@@ -141 +141 @@
         const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) override final;
         const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) override final;
+        const ast::DeclWithType *     visit( const ast::InlineMemberDecl     * ) override final;
         const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) override final;
         const ast::Stmt *             visit( const ast::ExprStmt             * ) override final;

src/AST/Pass.impl.hpp

@@ -617 +617 @@
                                 maybe_accept( node, &FunctionDecl::returns );
                                 maybe_accept( node, &FunctionDecl::type );
+                                maybe_accept( node, &FunctionDecl::attributes );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
@@ -625 +626 @@
                                 atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
-                                maybe_accept( node, &FunctionDecl::attributes );
                         }
                 }
@@ -800 +800 @@
 
         VISIT_END( StaticAssertDecl, node );
+}
+
+//--------------------------------------------------------------------------
+// InlineMemberDecl
+template< typename core_t >
+const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineMemberDecl * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                {
+                        guard_symtab guard { *this };
+                        maybe_accept( node, &InlineMemberDecl::type );
+                }
+        }
+
+        VISIT_END( DeclWithType, node );
 }
 

src/AST/Print.cpp

@@ -398 +398 @@
         virtual const ast::Decl * visit( const ast::StructDecl * node ) override final {
                 print(node);
+                return node;
+        }
+
+        virtual const ast::DeclWithType * visit( const ast::InlineMemberDecl * node ) override final {
+                os << "inline ";
+                if ( ! node->name.empty() ) os << node->name;
+
                 return node;
         }

src/AST/Type.cpp

@@ -147 +147 @@
 // --- TypeInstType
 
+bool TypeInstType::operator==( const TypeInstType & other ) const {
+        return base == other.base
+                && formal_usage == other.formal_usage
+                && expr_id == other.expr_id;
+}
+
 TypeInstType::TypeInstType( const TypeDecl * b,
         CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
@@ -157 +163 @@
 
 bool TypeInstType::isComplete() const { return base->sized; }
+
+std::string TypeInstType::TypeEnvKey::typeString() const {
+        return std::string("_") + std::to_string(formal_usage)
+                + "_" + std::to_string(expr_id) + "_" + base->name;
+}
+
+bool TypeInstType::TypeEnvKey::operator==(
+                const TypeInstType::TypeEnvKey & other ) const {
+        return base == other.base
+                && formal_usage == other.formal_usage
+                && expr_id == other.expr_id;
+}
+
+bool TypeInstType::TypeEnvKey::operator<(
+                const TypeInstType::TypeEnvKey & other ) const {
+        // TypeEnvKey ordering is an arbitrary total ordering.
+        // It doesn't mean anything but allows for a sorting.
+        if ( base < other.base ) {
+                return true;
+        } else if ( other.base < base ) {
+                return false;
+        } else if ( formal_usage < other.formal_usage ) {
+                return true;
+        } else if ( other.formal_usage < formal_usage ) {
+                return false;
+        } else {
+                return expr_id < other.expr_id;
+        }
+}
 
 // --- TupleType

src/AST/Type.hpp

@@ -408 +408 @@
 
                 TypeEnvKey() = default;
-                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0): base(base), formal_usage(formal_usage), expr_id(expr_id) {}
-                TypeEnvKey(const TypeInstType & inst): base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
-                std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
-                bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
+                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0)
+                : base(base), formal_usage(formal_usage), expr_id(expr_id) {}
+                TypeEnvKey(const TypeInstType & inst)
+                : base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
+                std::string typeString() const;
+                bool operator==(const TypeEnvKey & other) const;
+                bool operator<(const TypeEnvKey & other) const;
         };
 
-        bool operator==(const TypeInstType & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
+        bool operator==(const TypeInstType & other) const;
 
         TypeInstType(

src/AST/Visitor.hpp

@@ -33 +33 @@
     virtual const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) = 0;
     virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) = 0;
+    virtual const ast::DeclWithType *     visit( const ast::InlineMemberDecl     * ) = 0;
     virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ExprStmt             * ) = 0;