Changeset e0e9a0b for src/AST

Timestamp:

Jun 27, 2019, 5:16:54 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

7d0881c

Parents:

6be3b7d6

Message:

Somewhat deeper clone for types with forall qualifiers.

• Added WithForallSubstitutor? pass accessory to perform these changes
• modified copy constructors of ParameterizedType? to properly update children

Location:

src/AST

Files:

• Decl.cpp (modified) (1 diff)
• Decl.hpp (modified) (6 diffs)
• ForallSubstitutionTable.cpp (added)
• ForallSubstitutionTable.hpp (added)
• ForallSubstitutor.hpp (added)
• Node.cpp (modified) (1 diff)
• Node.hpp (modified) (1 diff)
• Pass.hpp (modified) (5 diffs)
• Pass.impl.hpp (modified) (8 diffs)
• Pass.proto.hpp (modified) (2 diffs)
• Type.cpp (modified) (8 diffs)
• Type.hpp (modified) (11 diffs)
• module.mk (modified) (1 diff)

src/AST/Decl.cpp

@@ -52 +52 @@
 
 const Type * FunctionDecl::get_type() const { return type.get(); }
-void FunctionDecl::set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+void FunctionDecl::set_type( const Type * t ) {
+        type = strict_dynamic_cast< const FunctionType * >( t );
+}
 
 // --- TypeDecl

src/AST/Decl.hpp

@@ -87 +87 @@
         virtual const Type * get_type() const = 0;
         /// Set type of this declaration. May be verified by subclass
-        virtual void set_type(Type *) = 0;
+        virtual void set_type( const Type * ) = 0;
 
         const DeclWithType * accept( Visitor & v ) const override = 0;
@@ -110 +110 @@
 
         const Type* get_type() const override { return type; }
-        void set_type( Type * ty ) override { type = ty; }
+        void set_type( const Type * ty ) override { type = ty; }
 
         const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
@@ -132 +132 @@
 
         const Type * get_type() const override;
-        void set_type(Type * t) override;
+        void set_type( const Type * t ) override;
 
         bool has_body() const { return stmts; }
@@ -149 +149 @@
         std::vector<ptr<DeclWithType>> assertions;
 
-        NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
-                Type* b, Linkage::Spec spec = Linkage::Cforall )
+        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 ), params(), assertions() {}
 
@@ -185 +186 @@
         };
 
-        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b,
-                TypeVar::Kind k, bool s, Type* i = nullptr )
+        TypeDecl( 
+                const CodeLocation & loc, const std::string & name, Storage::Classes storage, 
+                const Type * b, TypeVar::Kind k, bool s, const Type * i = nullptr )
         : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ),
           init( i ) {}
@@ -201 +203 @@
         TypeDecl * clone() const override { return new TypeDecl{ *this }; }
         MUTATE_FRIEND
-        friend class ParameterizedType;  // to allow deep clones
 };
 

src/AST/Node.cpp

@@ -56 +56 @@
 
 template< typename node_t, enum ast::Node::ref_type ref_t >
-void ast::ptr_base<node_t, ref_t>::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); }
+void ast::ptr_base<node_t, ref_t>::_check() const { 
+        // if(node) assert(node->was_ever_strong == false || node->strong_count > 0);
+}
 
 template< typename node_t, enum ast::Node::ref_type ref_t >

src/AST/Node.hpp

@@ -125 +125 @@
 }
 
+/// Mutate an entire indexed collection by cloning to accepted value
+template<typename node_t, typename parent_t, typename coll_t>
+const node_t * mutate_each( const node_t * node, coll_t parent_t::* field, Visitor & v ) {
+        for ( unsigned i = 0; i < (node->*field).size(); ++i ) {
+                node = mutate_field_index( node, field, i, (node->*field)[i]->accept( v ) );
+        }
+        return node;
+}
+
 std::ostream& operator<< ( std::ostream& out, const Node * node );
 

src/AST/Pass.hpp

@@ -35 +35 @@
 #include "AST/SymbolTable.hpp"
 
+#include "AST/ForallSubstitutionTable.hpp"
+
 // Private prelude header, needed for some of the magic tricks this class pulls off
 #include "AST/Pass.proto.hpp"
@@ -46 +48 @@
 //
 // Several additional features are available through inheritance
-// | WithTypeSubstitution - provides polymorphic const TypeSubstitution * env for the
-//                          current expression
-// | WithStmtsToAdd       - provides the ability to insert statements before or after the current
-//                          statement by adding new statements into stmtsToAddBefore or
-//                          stmtsToAddAfter respectively.
-// | WithDeclsToAdd       - provides the ability to insert declarations before or after the current
-//                          declarations by adding new DeclStmt into declsToAddBefore or
-//                          declsToAddAfter respectively.
-// | WithShortCircuiting  - provides the ability to skip visiting child nodes; set visit_children
-//                          to false in pre{visit,visit} to skip visiting children
-// | WithGuards           - provides the ability to save/restore data like a LIFO stack; to save,
-//                          call GuardValue with the variable to save, the variable will
-//                          automatically be restored to its previous value after the corresponding
-//                          postvisit/postmutate teminates.
-// | WithVisitorRef       - provides an pointer to the templated visitor wrapper
-// | WithSymbolTable      - provides symbol table functionality
+// | WithTypeSubstitution  - provides polymorphic const TypeSubstitution * env for the
+//                           current expression
+// | WithStmtsToAdd        - provides the ability to insert statements before or after the current
+//                           statement by adding new statements into stmtsToAddBefore or
+//                           stmtsToAddAfter respectively.
+// | WithDeclsToAdd        - provides the ability to insert declarations before or after the
+//                           current declarations by adding new DeclStmt into declsToAddBefore or
+//                           declsToAddAfter respectively.
+// | WithShortCircuiting   - provides the ability to skip visiting child nodes; set visit_children
+//                           to false in pre{visit,visit} to skip visiting children
+// | WithGuards            - provides the ability to save/restore data like a LIFO stack; to save,
+//                           call GuardValue with the variable to save, the variable will
+//                           automatically be restored to its previous value after the
+//                           corresponding postvisit/postmutate teminates.
+// | WithVisitorRef        - provides an pointer to the templated visitor wrapper
+// | WithSymbolTable       - provides symbol table functionality
+// | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
 //-------------------------------------------------------------------------------------------------
 template< typename pass_t >
@@ -201 +204 @@
         container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
 
+        /// Mutate forall-list, accounting for presence of type substitution map
+        template<typename node_t>
+        void mutate_forall( const node_t *& );
+
 public:
         /// Logic to call the accept and mutate the parent if needed, delegates call to accept
@@ -221 +228 @@
         };
 
+        /// Internal RAII guard for forall substitutions
+        struct guard_forall_subs {
+                guard_forall_subs( Pass<pass_t> & pass, const ParameterizedType * type )
+                : pass( pass ), type( type ) { __pass::forall::enter(pass.pass, 0, type ); }
+                ~guard_forall_subs()         { __pass::forall::leave(pass.pass, 0, type ); }
+                Pass<pass_t> & pass;
+                const ParameterizedType * type;
+        };
+
 private:
         bool inFunction = false;
@@ -313 +329 @@
         SymbolTable symtab;
 };
+
+/// Use when the templated visitor needs to keep TypeInstType instances properly linked to TypeDecl
+struct WithForallSubstitutor {
+        ForallSubstitutionTable subs;
+};
+
 }
 

src/AST/Pass.impl.hpp

@@ -127 +127 @@
                         , decltype( node->accept(*this) )
                 >::type
-
         {
                 __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( expr );
+                __pedantic_pass_assert( node );
 
                 static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
@@ -323 +322 @@
         }
 
+
+        template< typename pass_t >
+        template< typename node_t >
+        void ast::Pass< pass_t >::mutate_forall( const node_t *& node ) {
+                if ( auto subs = __pass::forall::subs( pass, 0 ) ) {
+                        // tracking TypeDecl substitution, full clone
+                        if ( node->forall.empty() ) return;
+
+                        node_t * mut = mutate( node );
+                        mut->forall = subs->clone( node->forall, *this );
+                        node = mut;
+                } else {
+                        // not tracking TypeDecl substitution, just mutate
+                        maybe_accept( node, &node_t::forall );
+                }
+        }
 }
 
@@ -1667 +1682 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &FunctionType::forall  );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1686 +1702 @@
         VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &StructInstType::forall );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &StructInstType::params );
         })
@@ -1699 +1716 @@
         VISIT_START( node );
 
-        __pass::symtab::addStruct( pass, 0, node->name );
-
-        {
+        __pass::symtab::addUnion( pass, 0, node->name );
+
+        VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &UnionInstType::forall );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &UnionInstType::params );
-        }
+        })
 
         VISIT_END( Type, node );
@@ -1716 +1734 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &EnumInstType::forall );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &EnumInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1730 +1749 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &TraitInstType::forall );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &TraitInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1745 +1765 @@
 
         VISIT(
-                maybe_accept( node, &TypeInstType::forall );
-                maybe_accept( node, &TypeInstType::params );
+                {
+                        guard_forall_subs forall_guard { *this, node };
+                        mutate_forall( node );
+                        maybe_accept( node, &TypeInstType::params );
+                }
+                // ensure that base re-bound if doing substitution
+                __pass::forall::replace( pass, 0, node );
         )
 

src/AST/Pass.proto.hpp

@@ -263 +263 @@
                 template<typename pass_t>
                 static inline void leave( pass_t &, long ) {}
-        };
-
-        // Finally certain pass desire an up to date symbol table automatically
+        } // namespace scope
+
+        // Certain passes desire an up to date symbol table automatically
         // detect the presence of a member name `symtab` and call all the members appropriately
         namespace symtab {
@@ -356 +356 @@
                 #undef SYMTAB_FUNC1
                 #undef SYMTAB_FUNC2
-        };
-};
-};
+        } // namespace symtab
+
+        // Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
+        // Detect the presence of a member name `subs` and call all members appropriately
+        namespace forall {
+                // Some simple scoping rules
+                template<typename pass_t>
+                static inline auto enter( pass_t & pass, int, const ast::ParameterizedType * type ) 
+                -> decltype( pass.subs, void() ) {
+                        if ( ! type->forall.empty() ) pass.subs.beginScope();
+                }
+
+                template<typename pass_t>
+                static inline auto enter( pass_t &, long, const ast::ParameterizedType * ) {}
+
+                template<typename pass_t>
+                static inline auto leave( pass_t & pass, int, const ast::ParameterizedType * type ) 
+                -> decltype( pass.subs, void() ) {
+                        if ( ! type->forall.empty() ) { pass.subs.endScope(); }
+                }
+
+                template<typename pass_t>
+                static inline auto leave( pass_t &, long, const ast::ParameterizedType * ) {}
+
+                // Get the substitution table, if present
+                template<typename pass_t>
+                static inline auto subs( pass_t & pass, int ) -> decltype( &pass.subs ) {
+                        return &pass.subs;
+                }
+                
+                template<typename pass_t>
+                static inline ast::ForallSubstitutionTable * subs( pass_t &, long ) { return nullptr; }
+
+                // Replaces a TypeInstType's base TypeDecl according to the table
+                template<typename pass_t>
+                static inline auto replace( pass_t & pass, int, const ast::TypeInstType *& inst ) 
+                -> decltype( pass.subs, void() ) {
+                        inst = ast::mutate_field( 
+                                inst, &ast::TypeInstType::base, pass.subs.replace( inst->base ) );
+                }
+
+                template<typename pass_t>
+                static inline auto replace( pass_t &, long, const ast::TypeInstType *& ) {}
+
+        } // namespace forall
+} // namespace __pass
+} // namespace ast

src/AST/Type.cpp

@@ -21 +21 @@
 
 #include "Decl.hpp"
+#include "ForallSubstitutor.hpp" // for substituteForall
 #include "Init.hpp"
+#include "Common/utility.h"      // for copy, move
 #include "InitTweak/InitTweak.h" // for getPointerBase
 #include "Tuples/Tuples.h"       // for isTtype
@@ -91 +93 @@
 );
 
+// --- ParameterizedType
+
+void ParameterizedType::initWithSub( 
+        const ParameterizedType & o, Pass< ForallSubstitutor > & sub 
+) {
+        forall = sub.pass( o.forall );
+}
+
 // --- FunctionType
+
+FunctionType::FunctionType( const FunctionType & o )
+: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(), 
+  isVarArgs( o.isVarArgs ) {
+        Pass< ForallSubstitutor > sub;
+        initWithSub( o, sub );           // initialize substitution map
+        returns = sub.pass( o.returns ); // apply to return and parameter types
+        params = sub.pass( o.params );
+}
 
 namespace {
@@ -107 +126 @@
 
 // --- ReferenceToType
+
+void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) {
+        ParameterizedType::initWithSub( o, sub ); // initialize substitution
+        params = sub.pass( o.params );            // apply to parameters
+}
+
+ReferenceToType::ReferenceToType( const ReferenceToType & o )
+: ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ), 
+  hoistType( o.hoistType ) {
+        Pass< ForallSubstitutor > sub;
+        initWithSub( o, sub );
+}
+
 std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
@@ -119 +151 @@
 // --- StructInstType
 
-StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+StructInstType::StructInstType( 
+        const StructDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 bool StructInstType::isComplete() const { return base ? base->body : false; }
@@ -127 +159 @@
 // --- UnionInstType
 
-UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+UnionInstType::UnionInstType( 
+        const UnionDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 bool UnionInstType::isComplete() const { return base ? base->body : false; }
@@ -135 +167 @@
 // --- EnumInstType
 
-EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+EnumInstType::EnumInstType( 
+        const EnumDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 bool EnumInstType::isComplete() const { return base ? base->body : false; }
@@ -143 +175 @@
 // --- TraitInstType
 
-TraitInstType::TraitInstType( const TraitDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+TraitInstType::TraitInstType( 
+        const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 // --- TypeInstType
+
+TypeInstType::TypeInstType( const TypeInstType & o ) 
+: ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
+        Pass< ForallSubstitutor > sub;
+        initWithSub( o, sub );      // initialize substitution
+        base = sub.pass( o.base );  // apply to base type
+}
 
 void TypeInstType::set_base( const TypeDecl * b ) {
@@ -159 +198 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( std::move(ts) ), members() {
+: Type( q ), types( 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

src/AST/Type.hpp

@@ -33 +33 @@
 
 namespace ast {
+
+template< typename T > class Pass;
+class ForallSubstitutor;
 
 class Type : public Node {
@@ -266 +269 @@
 /// Base type for potentially forall-qualified types
 class ParameterizedType : public Type {
+protected:
+        /// initializes forall with substitutor
+        void initWithSub( const ParameterizedType & o, Pass< ForallSubstitutor > & sub );
 public:
         using ForallList = std::vector<ptr<TypeDecl>>;
@@ -278 +284 @@
         : Type(q, std::move(as)), forall() {}
 
-        ParameterizedType( const ParameterizedType & o ) : Type( o ), forall() {
-                // one-level deep clone to avoid weak-reference errors
-                forall.reserve( o.forall.size() );
-                for ( const TypeDecl * d : o.forall ) { forall.emplace_back( d->clone() ); }
-        }
+        // enforce use of ForallSubstitutor to copy parameterized type
+        ParameterizedType( const ParameterizedType & ) = delete;
 
         ParameterizedType( ParameterizedType && ) = default;
@@ -312 +315 @@
         : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
 
+        FunctionType( const FunctionType & o );
+
         /// true if either the parameters or return values contain a tttype
         bool isTtype() const;
@@ -325 +330 @@
 /// base class for types that refer to types declared elsewhere (aggregates and typedefs)
 class ReferenceToType : public ParameterizedType {
+protected:
+        /// Initializes forall and parameters based on substitutor
+        void initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub );
 public:
         std::vector<ptr<Expr>> params;
@@ -330 +338 @@
         bool hoistType = false;
 
-        ReferenceToType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        ReferenceToType( 
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
+
+        ReferenceToType( const ReferenceToType & o );
 
         /// Gets aggregate declaration this type refers to
@@ -349 +359 @@
         readonly<StructDecl> base;
 
-        StructInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        StructInstType( 
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        StructInstType( const StructDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+
+        StructInstType( 
+                const StructDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;
@@ -370 +381 @@
         readonly<UnionDecl> base;
 
-        UnionInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        UnionInstType( 
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        UnionInstType( const UnionDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+
+        UnionInstType( 
+                const UnionDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;
@@ -391 +403 @@
         readonly<EnumDecl> base;
 
-        EnumInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        EnumInstType( 
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        EnumInstType( const EnumDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+
+        EnumInstType( 
+                const EnumDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;
@@ -412 +425 @@
         readonly<TraitDecl> base;
 
-        TraitInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        TraitInstType( 
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        TraitInstType( const TraitDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+        
+        TraitInstType( 
+                const TraitDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         // not meaningful for TraitInstType
@@ -435 +449 @@
         TypeVar::Kind kind;
 
-        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
+        TypeInstType( 
+                const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
-        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
+        
+        TypeInstType( 
+                const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
+
+        TypeInstType( const TypeInstType & o );
 
         /// sets `base`, updating `kind` correctly

src/AST/module.mk

@@ -22 +22 @@
         AST/DeclReplacer.cpp \
         AST/Expr.cpp \
+        AST/ForallSubstitutionTable.cpp \
         AST/GenericSubstitution.cpp \
         AST/Init.cpp \