Changeset acd80b4

Timestamp:

May 16, 2019, 4:56:56 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

6f8e87d

Parents:

41b24c8

Message:

Fixed several compilation errors

Location:

src/AST

Files:

• Expr.cpp (modified) (1 diff)
• Expr.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (1 diff)
• Stmt.hpp (modified) (1 diff)
• Type.cpp (modified) (7 diffs)
• Type.hpp (modified) (1 diff)
• TypeSubstitution.hpp (modified) (1 diff)

src/AST/Expr.cpp ¶

@@ -256 +256 @@
 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
 
-// --- UntypedOffsetofExpr
-
-UntypedOffsetofExpr::UntypedOffsetofExpr(
-        const CodeLocation & loc, const Type * ty, const std::string & mem )
-: Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), type( ty ), member( mem ) {
-        assert( type );
-}
-
 // --- OffsetofExpr
 

src/AST/Expr.hpp ¶

@@ -28 +28 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {

src/AST/Pass.impl.hpp ¶

@@ -782 +782 @@
 
         VISIT(
-                maybe_accept( node, &TryStmt::block        );
-                maybe_accept( node, &TryStmt::handlers     );
-                maybe_accept( node, &TryStmt::finallyBlock );
+                maybe_accept( node, &TryStmt::body     );
+                maybe_accept( node, &TryStmt::handlers );
+                maybe_accept( node, &TryStmt::finally  );
         )
 

src/AST/Stmt.hpp ¶

@@ -27 +27 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {

src/AST/Type.cpp ¶

@@ -42 +42 @@
         const Type * t;
         const ReferenceType * r;
-        for ( t = this; (r = dynamic_cast<const ReferenceType *>() ); t = r->base );
+        for ( t = this; (r = dynamic_cast<const ReferenceType *>(t) ); t = r->base );
         return t;
 }
@@ -103 +103 @@
 
 bool FunctionType::isTtype() const {
-        return containsTtype( returnVals ) || containsTtype( parameters );
+        return containsTtype( returns ) || containsTtype( params );
 }
 
@@ -109 +109 @@
 std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
-        
+
         std::vector<readonly<Decl>> found;
         for ( const Decl * decl : aggr()->members ) {
@@ -119 +119 @@
 // --- StructInstType
 
-StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q = {}, 
-        std::vector<ptr<Attribute>>&& as = {} )
+StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
 : ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
@@ -127 +127 @@
 // --- UnionInstType
 
-UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q = {}, 
-        std::vector<ptr<Attribute>>&& as = {} )
+UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
 : ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
@@ -135 +135 @@
 // --- EnumInstType
 
-EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q = {}, 
-        std::vector<ptr<Attribute>>&& as = {} )
+EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
 : ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
@@ -152 +152 @@
 // --- TupleType
 
-TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} )
+TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
 : Type( q ), types( std::move(ts) ), members() {
-        // This constructor is awkward. `TupleType` needs to contain objects so that members can be 
-        // named, but members without initializer nodes end up getting constructors, which breaks 
-        // things. This happens because the object decls have to be visited so that their types are 
-        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps 
-        // be eliminated and replaced with a list-view over members. The temporary solution is to 
-        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not 
+        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
+        // named, but members without initializer nodes end up getting constructors, which breaks
+        // things. This happens because the object decls have to be visited so that their types are
+        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
+        // be eliminated and replaced with a list-view over members. The temporary solution is to
+        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
         // constructed. Potential better solutions include:
-        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`, 
+        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
         //      similar to the aggregate types.
-        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced 
+        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
         //      by `genInit`, rather than the current boolean flag.
         members.reserve( types.size() );
         for ( const Type * ty : types ) {
                 members.emplace_back( new ObjectDecl{
-                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, MaybeConstruct ), 
+                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, MaybeConstruct ),
                         Storage::Classes{}, Linkage::Cforall } );
         }

src/AST/Type.hpp ¶

@@ -30 +30 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {

src/AST/TypeSubstitution.hpp ¶

@@ -189 +189 @@
 }
 
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class TypeSubstitution * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TypeSubstitution * node, Node::ref_type ref ) { node->decrement(ref); }
-
 } // namespace ast