Changes in src/AST/Convert.cpp [1ae47de:1e5dedc4]

File:

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

src/AST/Convert.cpp

@@ -993 +993 @@
         const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
                 auto rslt = new UniqueExpr(
-                        get<Expression>().accept1(node->expr),
-                        node->id
+                        get<Expression>().accept1(node->expr)
                 );
 
@@ -1075 +1074 @@
         }
 
-        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 +1085 @@
                         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 +1096 @@
                         (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 +1107 @@
                         (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 +1136 @@
                 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 +1161 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1183 +1181 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1201 +1201 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1219 +1221 @@
                         };
                 }
-                return postvisit( node, ty );
+                postvisit( node, ty );
+                this->node = ty;
+                return nullptr;
         }
 
@@ -1239 +1243 @@
                         };
                 }
-                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;
         }
 
@@ -1895 +1907 @@
                 };
                 stmt->orElse = {
-                        GET_ACCEPT_1(timeout.statement, Stmt),
-                        GET_ACCEPT_1(timeout.condition, Expr),
+                        GET_ACCEPT_1(orelse.statement, Stmt),
+                        GET_ACCEPT_1(orelse.condition, Expr),
                 };
 
@@ -2355 +2367 @@
                 auto rslt = new ast::UniqueExpr(
                         old->location,
-                        GET_ACCEPT_1(expr, Expr),
-                        old->get_id()
+                        GET_ACCEPT_1(expr, Expr)
                 );
                 rslt->object = GET_ACCEPT_1(object, ObjectDecl);
@@ -2429 +2440 @@
         }
 
-        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 +2450 @@
                         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 +2460 @@
                         (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 +2470 @@
                         (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 +2496 @@
                 ty->params = GET_ACCEPT_V( parameters, DeclWithType );
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
-                visitType( old, ty );
+                this->node = ty;
         }
 
@@ -2500 +2503 @@
                 ty->params = GET_ACCEPT_V( parameters, Expr );
                 ty->hoistType = old->hoistType;
-                visitType( old, ty );
         }
 
@@ -2519 +2521 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2537 +2540 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2555 +2559 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2573 +2578 @@
                 }
                 postvisit( old, ty );
+                this->node = ty;
         }
 
@@ -2593 +2599 @@
                 }
                 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 +2623 @@
 
         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{};
         }