Changes in src/AST/Decl.hpp [a00a2c1:07de76b]

File:

• src/AST/Decl.hpp (modified) (8 diffs)

src/AST/Decl.hpp

@@ -33 +33 @@
 
 // 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 node_t * mutate(const node_t * node); \
-        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
@@ -79 +77 @@
         ptr<Expr> asmName;
         bool isDeleted = false;
-        bool isTypeFixed = false;
 
         DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
@@ -91 +88 @@
         virtual const Type * get_type() const = 0;
         /// Set type of this declaration. May be verified by subclass
-        virtual void set_type( const Type * ) = 0;
+        virtual void set_type(Type *) = 0;
 
         const DeclWithType * accept( Visitor & v ) const override = 0;
@@ -114 +111 @@
 
         const Type* get_type() const override { return type; }
-        void set_type( const Type * ty ) override { type = ty; }
+        void set_type( Type * ty ) override { type = ty; }
 
         const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
@@ -125 +122 @@
 class FunctionDecl : public DeclWithType {
 public:
-        std::vector<ptr<DeclWithType>> params;
-        std::vector<ptr<DeclWithType>> returns;
-        std::vector<ptr<TypeDecl>> type_params;
-        std::vector<ptr<DeclWithType>> assertions;
-        // declared type, derived from parameter declarations
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
         std::vector< ptr<Expr> > withExprs;
 
-
-        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
-                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+        FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
-        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
-        //  stmts( stmts ) {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
+          stmts( stmts ) {}
 
         const Type * get_type() const override;
-        void set_type( const Type * t ) override;
+        void set_type(Type * t) override;
 
         bool has_body() const { return stmts; }
@@ -157 +147 @@
 public:
         ptr<Type> base;
+        std::vector<ptr<TypeDecl>> params;
         std::vector<ptr<DeclWithType>> assertions;
 
-        NamedTypeDecl(
-                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
-                const Type * b, Linkage::Spec spec = Linkage::Cforall )
-        : Decl( loc, name, storage, spec ), base( b ), assertions() {}
+        NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
+                Type* b, Linkage::Spec spec = Linkage::Cforall )
+        : Decl( loc, name, storage, spec ), base( b ), params(), assertions() {}
 
         /// Produces a name for the kind of alias
@@ -196 +186 @@
         };
 
-        TypeDecl(
-                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
-                const Type * b, TypeDecl::Kind k, bool s, const Type * i = nullptr )
-        : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeDecl::Ttype || s ),
-          init( i ) {}
+        TypeDecl( const CodeLocation & loc, const std::string & name, Storage::Classes storage, Type * b,
+                          Kind k, bool s, Type * i = nullptr )
+                : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == Ttype || s ),
+                init( i ) {}
 
         const char * typeString() const override;
@@ -270 +259 @@
 
         bool is_coroutine() { return kind == Coroutine; }
-        bool is_generator() { return kind == Generator; }
-        bool is_monitor  () { return kind == Monitor  ; }
-        bool is_thread   () { return kind == Thread   ; }
+        bool is_monitor() { return kind == Monitor; }
+        bool is_thread() { return kind == Thread; }
 
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }