Changeset 71806e0 for src

Timestamp:

Nov 10, 2022, 8:21:54 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master

Children:

7491f97, e4d7c1c

Parents:

639e4fc

Message:

Rename InlineValueDecl to InlineMemberDecl

Location:

src

Files:

• AST/Convert.cpp (modified) (3 diffs)
• AST/Decl.hpp (modified) (2 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/Visitor.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/InlineMemberDecl.cc (moved) (moved from src/SynTree/InlineValueDecl.cc ) (2 diffs)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• SynTree/module.mk (modified) (1 diff)
• Validate/EnumAndPointerDecay.cpp (modified) (1 diff)

src/AST/Convert.cpp

@@ -236 +236 @@
         }
 
-        // InlineValueDecl vanish after EnumAndPointerDecay pass so no necessary to implement NewToOld
-        const ast::DeclWithType * visit( const ast::InlineValueDecl * node ) override final {   
+        // 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;
@@ -1869 +1869 @@
         }
 
-        virtual void visit( const InlineValueDecl * old ) override final {
+        virtual void visit( const InlineMemberDecl * old ) override final {
                 if ( inCache( old ) ) {
                         return;
@@ -1876 +1876 @@
                 auto&& attr = GET_ACCEPT_V(attributes, Attribute);
  
-                auto decl = new ast::InlineValueDecl(
+                auto decl = new ast::InlineMemberDecl(
                         old->location,
                         old->name,

src/AST/Decl.hpp

@@ -411 +411 @@
 };
 
-class InlineValueDecl final : public DeclWithType {
+class InlineMemberDecl final : public DeclWithType {
 public:
         ptr<Type> type;
 
-        InlineValueDecl( const CodeLocation & loc, const std::string & name, const 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 = {} )
@@ -425 +425 @@
         const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
 private:
-        InlineValueDecl * clone() const override { return new InlineValueDecl{ *this }; }
+        InlineMemberDecl * clone() const override { return new InlineMemberDecl{ *this }; }
         MUTATE_FRIEND
 };

src/AST/Fwd.hpp

@@ -37 +37 @@
 class DirectiveDecl;
 class StaticAssertDecl;
-class InlineValueDecl;
+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::InlineValueDecl      * ) 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

@@ -805 +805 @@
 // DeclWithType
 template< typename core_t >
-const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineValueDecl * node ) {
-        VISIT_START( node );
-
-        if ( __visit_children() ) {
-                {
-                        guard_symtab guard { *this };
-                        maybe_accept( node, &InlineValueDecl::type );
+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 );
                 }
         }

src/AST/Print.cpp

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

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::InlineValueDecl      * ) = 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;

src/Common/CodeLocationTools.cpp

@@ -111 +111 @@
     macro(DirectiveDecl, DirectiveDecl) \
     macro(StaticAssertDecl, StaticAssertDecl) \
-    macro(InlineValueDecl, DeclWithType) \
+    macro(InlineMemberDecl, DeclWithType) \
     macro(CompoundStmt, CompoundStmt) \
     macro(ExprStmt, Stmt) \

src/Common/PassVisitor.h

@@ -81 +81 @@
         virtual void visit( StaticAssertDecl * assertDecl ) override final;
         virtual void visit( const StaticAssertDecl * assertDecl ) override final;
-        virtual void visit( InlineValueDecl * valueDecl ) override final;
-        virtual void visit( const InlineValueDecl * valueDecl ) override final;
+        virtual void visit( InlineMemberDecl * valueDecl ) override final;
+        virtual void visit( const InlineMemberDecl * valueDecl ) override final;
 
         virtual void visit( CompoundStmt * compoundStmt ) override final;
@@ -275 +275 @@
         virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) override final;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
-        virtual DeclarationWithType * mutate( InlineValueDecl * valueDecl ) override final;
+        virtual DeclarationWithType * mutate( InlineMemberDecl * valueDecl ) override final;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -1047 +1047 @@
 
 //--------------------------------------------------------------------------
-// InlineValueDecl
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( InlineValueDecl * node ) {
+// InlineMemberDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( InlineMemberDecl * node ) {
         VISIT_START( node );
 
@@ -1058 +1058 @@
 
 template< typename pass_type >
-void PassVisitor< pass_type >::visit( const InlineValueDecl * node ) {
+void PassVisitor< pass_type >::visit( const InlineMemberDecl * node ) {
         VISIT_START( node );
 
@@ -1067 +1067 @@
 
 template< typename pass_type >
-DeclarationWithType * PassVisitor< pass_type >::mutate( InlineValueDecl * node ) {
+DeclarationWithType * PassVisitor< pass_type >::mutate( InlineMemberDecl * node ) {
         MUTATE_START( node );
 

src/Parser/DeclarationNode.cc

@@ -27 +27 @@
 #include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
 #include "SynTree/Attribute.h"     // for Attribute
-#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineValueDecl, Declaration
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineMemberDecl, Declaration
 #include "SynTree/Expression.h"    // for Expression, ConstantExpr
 #include "SynTree/Statement.h"     // for AsmStmt
@@ -1166 +1166 @@
         } // if
         if ( enumInLine ) {
-                return new InlineValueDecl( *name, storageClasses, linkage, nullptr );
+                return new InlineMemberDecl( *name, storageClasses, linkage, nullptr );
         } // if
         assertf( name, "ObjectDecl must a have name\n" );

src/SynTree/Declaration.h

@@ -450 +450 @@
 
 
-class InlineValueDecl : public DeclarationWithType {
+class InlineMemberDecl : public DeclarationWithType {
         typedef DeclarationWithType Parent;
   public:
         Type * type;
 
-        InlineValueDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Type * type,
+        InlineMemberDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Type * type,
                                 const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
-        InlineValueDecl( const InlineValueDecl & other );
-        virtual ~InlineValueDecl();
+        InlineMemberDecl( const InlineMemberDecl & other );
+        virtual ~InlineMemberDecl();
 
         virtual Type * get_type() const override { return type; }
         virtual void set_type(Type * newType) override { type = newType; }
 
-        static InlineValueDecl * newInlineValueDecl( const std::string & name, Type * type );
-
-        virtual InlineValueDecl * clone() const override { return new InlineValueDecl( *this ); }
+        static InlineMemberDecl * newInlineMemberDecl( const std::string & name, Type * type );
+
+        virtual InlineMemberDecl * clone() const override { return new InlineMemberDecl( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }

src/SynTree/InlineMemberDecl.cc

@@ -9 +9 @@
 #include "Type.h"                // for Type, Type::StorageClasses, Type::Fu...
 
-InlineValueDecl::InlineValueDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage,
+InlineMemberDecl::InlineMemberDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage,
 Type * type, const std::list< Attribute * >attributes, Type::FuncSpecifiers fs) 
     : Parent( name, scs, linkage, attributes, fs ), type( type ) {}
 
-InlineValueDecl::InlineValueDecl( const InlineValueDecl &other) 
+InlineMemberDecl::InlineMemberDecl( const InlineMemberDecl &other) 
     : Parent( other), type( maybeClone( other.type ) ) {}
 
-InlineValueDecl::~InlineValueDecl() { delete type; }
+InlineMemberDecl::~InlineMemberDecl() { delete type; }
 
-InlineValueDecl * InlineValueDecl::newInlineValueDecl( const std::string &name, Type * type ) {
-    return new InlineValueDecl( name, Type::StorageClasses(), LinkageSpec::C, type );
+InlineMemberDecl * InlineMemberDecl::newInlineMemberDecl( const std::string &name, Type * type ) {
+    return new InlineMemberDecl( name, Type::StorageClasses(), LinkageSpec::C, type );
 }
 
-void InlineValueDecl::print( std::ostream &os, Indenter indent ) const {
+void InlineMemberDecl::print( std::ostream &os, Indenter indent ) const {
     if ( name != "" ) os << name << ": ";
 
@@ -44 +44 @@
 }
 
-void InlineValueDecl::printShort( std::ostream &os, Indenter indent ) const {
+void InlineMemberDecl::printShort( std::ostream &os, Indenter indent ) const {
     if ( name != "" ) os << name << ": ";
 

src/SynTree/Mutator.h

@@ -36 +36 @@
         virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) = 0;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
-        virtual DeclarationWithType * mutate( InlineValueDecl * inlineValueDecl ) = 0;
+        virtual DeclarationWithType * mutate( InlineMemberDecl * InlineMemberDecl ) = 0;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;

src/SynTree/SynTree.h

@@ -38 +38 @@
 class DirectiveDecl;
 class StaticAssertDecl;
-class InlineValueDecl;
+class InlineMemberDecl;
 
 class Statement;

src/SynTree/Visitor.h

@@ -49 +49 @@
         virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
         virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
-        virtual void visit( InlineValueDecl * node ) { visit( const_cast<const InlineValueDecl *>(node) ); }
-        virtual void visit( const InlineValueDecl * valueDecl ) = 0;
+        virtual void visit( InlineMemberDecl * node ) { visit( const_cast<const InlineMemberDecl *>(node) ); }
+        virtual void visit( const InlineMemberDecl * valueDecl ) = 0;
 
         virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }

src/SynTree/module.mk

@@ -42 +42 @@
       SynTree/Initializer.cc \
       SynTree/Initializer.h \
-      SynTree/InlineValueDecl.cc \
+      SynTree/InlineMemberDecl.cc \
       SynTree/Label.h \
       SynTree/LinkageSpec.cc \

src/Validate/EnumAndPointerDecay.cpp

@@ -44 +44 @@
                 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>() ) {
+                } else if ( ast::InlineMemberDecl const * value = (*it).as<ast::InlineMemberDecl>() ) {
                         if ( auto targetEnum = symtab.lookupEnum( value->name ) ) {
                                 for ( auto singleMember : targetEnum->members ) {