Changes in / [c0f9efe:b69233ac]

Location:

src/AST

Files:

• Convert.cpp (modified) (22 diffs)
• Type.hpp (modified) (2 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 {
-                return visitType( node, new VoidType{ cv( node ) } );
+                this->node = new VoidType{ cv( node ) };
+                return nullptr;
         }
 
@@ -1094 +1086 @@
                         Validate::SizeType = type;
                 }
-                return visitType( node, type );
+                this->node = type;
+                return nullptr;
         }
 
         const ast::Type * visit( const ast::PointerType * node ) override final {
-                return visitType( node, new PointerType{
+                this->node = new PointerType{
                         cv( node ),
                         get<Type>().accept1( node->base ),
@@ -1104 +1097 @@
                         (bool)node->isVarLen,
                         (bool)node->isStatic
-                } );
+                };
+                return nullptr;
         }
 
         const ast::Type * visit( const ast::ArrayType * node ) override final {
-                return visitType( node, new ArrayType{
+                this->node = new ArrayType{
                         cv( node ),
                         get<Type>().accept1( node->base ),
@@ -1114 +1108 @@
                         (bool)node->isVarLen,
                         (bool)node->isStatic
-                } );
+                };
+                return nullptr;
         }
 
         const ast::Type * visit( const ast::ReferenceType * node ) override final {
-                return visitType( node, new ReferenceType{
+                this->node = new ReferenceType{
                         cv( node ),
                         get<Type>().accept1( node->base )
-                } );
+                };
+                return nullptr;
         }
 
         const ast::Type * visit( const ast::QualifiedType * node ) override final {
-                return visitType( node, new QualifiedType{
+                this->node = new QualifiedType{
                         cv( node ),
                         get<Type>().accept1( node->parent ),
                         get<Type>().accept1( node->child )
-                } );
+                };
+                return nullptr;
         }
 
@@ -1140 +1137 @@
                 ty->parameters = get<DeclarationWithType>().acceptL( node->params );
                 ty->forall = get<TypeDecl>().acceptL( node->forall );
-                return visitType( node, ty );
-        }
-
-        const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
+                this->node = ty;
+                return nullptr;
+        }
+
+        void 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 );
         }
 
@@ -1165 +1162 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1183 +1182 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1201 +1202 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1219 +1222 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1239 +1244 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
         const ast::Type * visit( const ast::TupleType * node ) override final {
-                return visitType( node, new TupleType{
+                this->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 {
-                return visitType( node, new TypeofType{
+                this->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 {
-                return visitType( node, new VarArgsType{ cv( node ) } );
+                this->node = new VarArgsType{ cv( node ) };
+                return nullptr;
         }
 
         const ast::Type * visit( const ast::ZeroType * node ) override final {
-                return visitType( node, new ZeroType{ cv( node ) } );
+                this->node = new ZeroType{ cv( node ) };
+                return nullptr;
         }
 
         const ast::Type * visit( const ast::OneType * node ) override final {
-                return visitType( node, new OneType{ cv( node ) } );
-        }
-
-        const ast::Type * visit( const ast::GlobalScopeType * node ) override final {
-                return visitType( node, new GlobalScopeType{} );
+                this->node = new OneType{ cv( node ) };
+                return nullptr;
+        }
+
+        const ast::Type * visit( const ast::GlobalScopeType * ) override final {
+                this->node = new GlobalScopeType{};
+                return nullptr;
         }
 
@@ -2429 +2442 @@
         }
 
-        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 {
-                visitType( old, new ast::VoidType{ cv( old ) } );
+                this->node = new ast::VoidType{ cv( old ) };
         }
 
@@ -2447 +2452 @@
                         sizeType = type;
                 }
-                visitType( old, type );
+                this->node = type;
         }
 
         virtual void visit( PointerType * old ) override final {
-                visitType( old, new ast::PointerType{
+                this->node = new ast::PointerType{
                         GET_ACCEPT_1( base, Type ),
                         GET_ACCEPT_1( dimension, Expr ),
@@ -2457 +2462 @@
                         (ast::DimensionFlag)old->isStatic,
                         cv( old )
-                } );
+                };
         }
 
         virtual void visit( ArrayType * old ) override final {
-                visitType( old, new ast::ArrayType{
+                this->node = new ast::ArrayType{
                         GET_ACCEPT_1( base, Type ),
                         GET_ACCEPT_1( dimension, Expr ),
@@ -2467 +2472 @@
                         (ast::DimensionFlag)old->isStatic,
                         cv( old )
-                } );
+                };
         }
 
         virtual void visit( ReferenceType * old ) override final {
-                visitType( old, new ast::ReferenceType{
+                this->node = new ast::ReferenceType{
                         GET_ACCEPT_1( base, Type ),
                         cv( old )
-                } );
+                };
         }
 
         virtual void visit( QualifiedType * old ) override final {
-                visitType( old, new ast::QualifiedType{
+                this->node = new ast::QualifiedType{
                         GET_ACCEPT_1( parent, Type ),
                         GET_ACCEPT_1( child, Type ),
                         cv( old )
-                } );
+                };
         }
 
@@ -2493 +2498 @@
                 ty->params = GET_ACCEPT_V( parameters, DeclWithType );
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
-                visitType( old, ty );
+                this->node = ty;
         }
 
@@ -2500 +2505 @@
                 ty->params = GET_ACCEPT_V( parameters, Expr );
                 ty->hoistType = old->hoistType;
-                visitType( old, ty );
         }
 
@@ -2519 +2523 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2537 +2542 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2555 +2561 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2573 +2580 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2593 +2601 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
         virtual void visit( TupleType * old ) override final {
-                visitType( old, new ast::TupleType{
+                this->node = new ast::TupleType{
                         GET_ACCEPT_V( types, Type ),
                         // members generated by TupleType c'tor
                         cv( old )
-                } );
+                };
         }
 
         virtual void visit( TypeofType * old ) override final {
-                visitType( old, new ast::TypeofType{
+                this->node = new ast::TypeofType{
                         GET_ACCEPT_1( expr, Expr ),
                         (ast::TypeofType::Kind)old->is_basetypeof,
                         cv( old )
-                } );
+                };
         }
 
@@ -2616 +2625 @@
 
         virtual void visit( VarArgsType * old ) override final {
-                visitType( old, new ast::VarArgsType{ cv( old ) } );
+                this->node = new ast::VarArgsType{ cv( old ) };
         }
 
         virtual void visit( ZeroType * old ) override final {
-                visitType( old, new ast::ZeroType{ cv( old ) } );
+                this->node = new ast::ZeroType{ cv( old ) };
         }
 
         virtual void visit( OneType * old ) override final {
-                visitType( old, new ast::OneType{ cv( old ) } );
-        }
-
-        virtual void visit( GlobalScopeType * old ) override final {
-                visitType( old, new ast::GlobalScopeType{} );
+                this->node = new ast::OneType{ cv( old ) };
+        }
+
+        virtual void visit( GlobalScopeType * ) override final {
+                this->node = new ast::GlobalScopeType{};
         }
 

src/AST/Type.hpp

@@ -39 +39 @@
         std::vector<ptr<Attribute>> attributes;
 
-        Type( CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        Type( CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} ) 
         : qualifiers(q), attributes(std::move(as)) {}
 
@@ -270 +270 @@
         ForallList forall;
 
-        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {},
+        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {}, 
                 std::vector<ptr<Attribute>> && as = {} )
         : Type(q, std::move(as)), forall(std::move(fs)) {}
-
-        ParameterizedType( CV::Qualifiers q, std::vector<ptr<Attribute>> && as = {} )
+        
+        ParameterizedType( CV::Qualifiers q, std::vector<ptr<Attribute>> && as = {} ) 
         : Type(q, std::move(as)), forall() {}