Changeset 3c6e417 for src/AST

Timestamp:

Jun 20, 2019, 1:45:01 PM (6 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

Location:

src/AST

Files:

• Convert.cpp (modified) (24 diffs)
• Expr.hpp (modified) (3 diffs)
• Type.hpp (modified) (4 diffs)
• TypeEnvironment.hpp (modified) (1 diff)
• porting.md (modified) (1 diff)

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{} );
         }
 

src/AST/Expr.hpp

@@ -47 +47 @@
 
         ParamEntry() : decl( 0 ), declptr( nullptr ), actualType( nullptr ), formalType( nullptr ), expr( nullptr ) {}
-        ParamEntry( UniqueId id, Decl * declptr, Type* actual, Type* formal, Expr* e )
+        ParamEntry( 
+                UniqueId id, const Decl * declptr, const Type * actual, const Type * formal, 
+                const Expr * e )
         : decl( id ), declptr( declptr ), actualType( actual ), formalType( formal ), expr( e ) {}
 };
@@ -129 +131 @@
                         case Params: return data.inferParams;
                         }
+                        assert(!"unreachable");
                         return *((InferredParams*)nullptr);
                 }
@@ -138 +141 @@
                         assert(!"Mode was not already Params");
                         return *((InferredParams*)nullptr);
+                }
+
+                void set_inferParams( InferredParams && ps ) {
+                        switch(mode) {
+                        case Slots: 
+                                data.resnSlots.~ResnSlots();
+                                // fallthrough
+                        case Empty: 
+                                new(&data.inferParams) InferredParams{ std::move( ps ) };
+                                mode = Params;
+                                break;
+                        case Params:
+                                data.inferParams = std::move( ps );
+                                break;
+                        }
                 }
 

src/AST/Type.hpp

@@ -37 +37 @@
 public:
         CV::Qualifiers qualifiers;
-
-        Type( CV::Qualifiers q = {} ) : qualifiers(q) {}
+        std::vector<ptr<Attribute>> attributes;
+
+        Type( CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : qualifiers(q), attributes(std::move(as)) {}
 
         bool is_const() const { return qualifiers.is_const; }
@@ -268 +270 @@
         ForallList forall;
 
-        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {} )
-        : Type(q), forall(std::move(fs)) {}
-        ParameterizedType( CV::Qualifiers q ) : Type(q), forall() {}
+        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 = {} )
+        : Type(q, std::move(as)), forall() {}
 
 private:
@@ -311 +316 @@
 public:
         std::vector<ptr<Expr>> params;
-        std::vector<ptr<Attribute>> attributes;
         std::string name;
         bool hoistType = false;
@@ -317 +321 @@
         ReferenceToType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
-        : ParameterizedType(q), params(), attributes(std::move(as)), name(n) {}
+        : ParameterizedType(q, std::move(as)), params(), name(n) {}
 
         /// Gets aggregate declaration this type refers to

src/AST/TypeEnvironment.hpp

@@ -215 +215 @@
 std::ostream & operator<<( std::ostream & out, const TypeEnvironment & env );
 
-}
+} // namespace ast
 
 // Local Variables: //

src/AST/porting.md

@@ -302 +302 @@
 * `ExplodedActual.h` => `ExplodedArg.hpp`
 
+`polyCost`
+* switched order of `env`, `symtab` parameters for better consistency
+
+`findMinCost`
+* pulled out conversion cost promotion into separate `promoteCvtCost` function
+
+`resolveAssertions` => `satisfyAssertions`
+* `ResolveAssertions.h` => `SatisfyAssertions.hpp`
+* `Resn*` => `Sat*`
+
 [1] https://gcc.gnu.org/onlinedocs/gcc-9.1.0/gcc/Type-Attributes.html#Type-Attributes