Changeset 1ae47de for src/AST/Convert.cpp

Timestamp:

Jun 19, 2019, 4:51:14 PM (5 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

c0f9efe

Parents:

17a0ede2

Message:

Convert now handles attributes on types.

File:

• src/AST/Convert.cpp (modified) (22 diffs)

src/AST/Convert.cpp

@@ -1075 +1075 @@
         }
 
+        const ast::Type * visitType( const ast::Type * node, Type * type ) {
+                // Some types do this in their constructor so add a check.
+                if ( !node->attributes.empty() && type->attributes.empty() ) {
+                        type->attributes = get<Attribute>().acceptL( node->attributes );
+                }
+                this->node = type;
+                return nullptr;
+        }
+
         const ast::Type * visit( const ast::VoidType * node ) override final {
-                this->node = new VoidType{ cv( node ) };
-                return nullptr;
+                return visitType( node, new VoidType{ cv( node ) } );
         }
 
@@ -1086 +1094 @@
                         Validate::SizeType = type;
                 }
-                this->node = type;
-                return nullptr;
+                return visitType( node, type );
         }
 
         const ast::Type * visit( const ast::PointerType * node ) override final {
-                this->node = new PointerType{
+                return visitType( node, new PointerType{
                         cv( node ),
                         get<Type>().accept1( node->base ),
@@ -1097 +1104 @@
                         (bool)node->isVarLen,
                         (bool)node->isStatic
-                };
-                return nullptr;
+                } );
         }
 
         const ast::Type * visit( const ast::ArrayType * node ) override final {
-                this->node = new ArrayType{
+                return visitType( node, new ArrayType{
                         cv( node ),
                         get<Type>().accept1( node->base ),
@@ -1108 +1114 @@
                         (bool)node->isVarLen,
                         (bool)node->isStatic
-                };
-                return nullptr;
+                } );
         }
 
         const ast::Type * visit( const ast::ReferenceType * node ) override final {
-                this->node = new ReferenceType{
+                return visitType( node, new ReferenceType{
                         cv( node ),
                         get<Type>().accept1( node->base )
-                };
-                return nullptr;
+                } );
         }
 
         const ast::Type * visit( const ast::QualifiedType * node ) override final {
-                this->node = new QualifiedType{
+                return visitType( node, new QualifiedType{
                         cv( node ),
                         get<Type>().accept1( node->parent ),
                         get<Type>().accept1( node->child )
-                };
-                return nullptr;
+                } );
         }
 
@@ -1137 +1140 @@
                 ty->parameters = get<DeclarationWithType>().acceptL( node->params );
                 ty->forall = get<TypeDecl>().acceptL( node->forall );
-                this->node = ty;
-                return nullptr;
-        }
-
-        void postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
+                return visitType( node, ty );
+        }
+
+        const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
                 ty->forall = get<TypeDecl>().acceptL( old->forall );
                 ty->parameters = get<Expression>().acceptL( old->params );
                 ty->hoistType = old->hoistType;
+                return visitType( old, ty );
         }
 
@@ -1162 +1165 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1182 +1183 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1202 +1201 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1222 +1219 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1244 +1239 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
         const ast::Type * visit( const ast::TupleType * node ) override final {
-                this->node = new TupleType{
+                return visitType( node, new TupleType{
                         cv( node ),
                         get<Type>().acceptL( node->types )
                         // members generated by TupleType c'tor
-                };
-                return nullptr;
+                } );
         }
 
         const ast::Type * visit( const ast::TypeofType * node ) override final {
-                this->node = new TypeofType{
+                return visitType( node, new TypeofType{
                         cv( node ),
                         get<Expression>().accept1( node->expr ),
                         (bool)node->kind
-                };
-                return nullptr;
+                } );
         }
 
         const ast::Type * visit( const ast::VarArgsType * node ) override final {
-                this->node = new VarArgsType{ cv( node ) };
-                return nullptr;
+                return visitType( node, new VarArgsType{ cv( node ) } );
         }
 
         const ast::Type * visit( const ast::ZeroType * node ) override final {
-                this->node = new ZeroType{ cv( node ) };
-                return nullptr;
+                return visitType( node, new ZeroType{ cv( node ) } );
         }
 
         const ast::Type * visit( const ast::OneType * node ) override final {
-                this->node = new OneType{ cv( node ) };
-                return nullptr;
-        }
-
-        const ast::Type * visit( const ast::GlobalScopeType * ) override final {
-                this->node = new GlobalScopeType{};
-                return nullptr;
+                return visitType( node, new OneType{ cv( node ) } );
+        }
+
+        const ast::Type * visit( const ast::GlobalScopeType * node ) override final {
+                return visitType( node, new GlobalScopeType{} );
         }
 
@@ -2442 +2429 @@
         }
 
+        void visitType( Type * old, ast::Type * type ) {
+                // Some types do this in their constructor so add a check.
+                if ( !old->attributes.empty() && type->attributes.empty() ) {
+                        type->attributes = GET_ACCEPT_V(attributes, Attribute);
+                }
+                this->node = type;
+        }
+
         virtual void visit( VoidType * old ) override final {
-                this->node = new ast::VoidType{ cv( old ) };
+                visitType( old, new ast::VoidType{ cv( old ) } );
         }
 
@@ -2452 +2447 @@
                         sizeType = type;
                 }
-                this->node = type;
+                visitType( old, type );
         }
 
         virtual void visit( PointerType * old ) override final {
-                this->node = new ast::PointerType{
+                visitType( old, new ast::PointerType{
                         GET_ACCEPT_1( base, Type ),
                         GET_ACCEPT_1( dimension, Expr ),
@@ -2462 +2457 @@
                         (ast::DimensionFlag)old->isStatic,
                         cv( old )
-                };
+                } );
         }
 
         virtual void visit( ArrayType * old ) override final {
-                this->node = new ast::ArrayType{
+                visitType( old, new ast::ArrayType{
                         GET_ACCEPT_1( base, Type ),
                         GET_ACCEPT_1( dimension, Expr ),
@@ -2472 +2467 @@
                         (ast::DimensionFlag)old->isStatic,
                         cv( old )
-                };
+                } );
         }
 
         virtual void visit( ReferenceType * old ) override final {
-                this->node = new ast::ReferenceType{
+                visitType( old, new ast::ReferenceType{
                         GET_ACCEPT_1( base, Type ),
                         cv( old )
-                };
+                } );
         }
 
         virtual void visit( QualifiedType * old ) override final {
-                this->node = new ast::QualifiedType{
+                visitType( old, new ast::QualifiedType{
                         GET_ACCEPT_1( parent, Type ),
                         GET_ACCEPT_1( child, Type ),
                         cv( old )
-                };
+                } );
         }
 
@@ -2498 +2493 @@
                 ty->params = GET_ACCEPT_V( parameters, DeclWithType );
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
-                this->node = ty;
+                visitType( old, ty );
         }
 
@@ -2505 +2500 @@
                 ty->params = GET_ACCEPT_V( parameters, Expr );
                 ty->hoistType = old->hoistType;
+                visitType( old, ty );
         }
 
@@ -2523 +2519 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2542 +2537 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2561 +2555 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2580 +2573 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2601 +2593 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
         virtual void visit( TupleType * old ) override final {
-                this->node = new ast::TupleType{
+                visitType( old, new ast::TupleType{
                         GET_ACCEPT_V( types, Type ),
                         // members generated by TupleType c'tor
                         cv( old )
-                };
+                } );
         }
 
         virtual void visit( TypeofType * old ) override final {
-                this->node = new ast::TypeofType{
+                visitType( old, new ast::TypeofType{
                         GET_ACCEPT_1( expr, Expr ),
                         (ast::TypeofType::Kind)old->is_basetypeof,
                         cv( old )
-                };
+                } );
         }
 
@@ -2625 +2616 @@
 
         virtual void visit( VarArgsType * old ) override final {
-                this->node = new ast::VarArgsType{ cv( old ) };
+                visitType( old, new ast::VarArgsType{ cv( old ) } );
         }
 
         virtual void visit( ZeroType * old ) override final {
-                this->node = new ast::ZeroType{ cv( old ) };
+                visitType( old, new ast::ZeroType{ cv( old ) } );
         }
 
         virtual void visit( OneType * old ) override final {
-                this->node = new ast::OneType{ cv( old ) };
-        }
-
-        virtual void visit( GlobalScopeType * ) override final {
-                this->node = new ast::GlobalScopeType{};
+                visitType( old, new ast::OneType{ cv( old ) } );
+        }
+
+        virtual void visit( GlobalScopeType * old ) override final {
+                visitType( old, new ast::GlobalScopeType{} );
         }