Changeset 3c6e417 for src/AST/Convert.cpp

Timestamp:

Jun 20, 2019, 1:45:01 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

54dd994

Parents:

1e5dedc4 (diff), c0f9efe (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

File:

• src/AST/Convert.cpp (modified) (24 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)
+                        get<Expression>().accept1(node->expr),
+                        node->id
                 );
 
@@ -1074 +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 ) } );
         }
 
@@ -1085 +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 ),
@@ -1096 +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 ),
@@ -1107 +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;
+                } );
         }
 
@@ -1136 +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 );
         }
 
@@ -1161 +1165 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1181 +1183 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1201 +1201 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1221 +1219 @@
                         };
                 }
-                postvisit( node, ty );
-                this->node = ty;
-                return nullptr;
+                return postvisit( node, ty );
         }
 
@@ -1243 +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{} );
         }
 
@@ -2367 +2355 @@
                 auto rslt = new ast::UniqueExpr(
                         old->location,
-                        GET_ACCEPT_1(expr, Expr)
+                        GET_ACCEPT_1(expr, Expr),
+                        old->get_id()
                 );
                 rslt->object = GET_ACCEPT_1(object, ObjectDecl);
@@ -2440 +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 ) } );
         }
 
@@ -2450 +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 ),
@@ -2460 +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 ),
@@ -2470 +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 )
-                };
+                } );
         }
 
@@ -2496 +2493 @@
                 ty->params = GET_ACCEPT_V( parameters, DeclWithType );
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
-                this->node = ty;
+                visitType( old, ty );
         }
 
@@ -2503 +2500 @@
                 ty->params = GET_ACCEPT_V( parameters, Expr );
                 ty->hoistType = old->hoistType;
+                visitType( old, ty );
         }
 
@@ -2521 +2519 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2540 +2537 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2559 +2555 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2578 +2573 @@
                 }
                 postvisit( old, ty );
-                this->node = ty;
         }
 
@@ -2599 +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 )
-                };
+                } );
         }
 
@@ -2623 +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{} );
         }