Changes in src/AST/Type.hpp [c9f6983:361bf01]

File:

• src/AST/Type.hpp (modified) (7 diffs)

src/AST/Type.hpp

@@ -36 +36 @@
 
 template< typename T > class Pass;
+
+struct ForallSubstitutor;
 
 class Type : public Node {
@@ -270 +272 @@
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {
-public:
-        using ForallList = std::vector<ptr<TypeInstType>>;
-        using AssertionList = std::vector<ptr<VariableExpr>>;
+        protected:
+        /// initializes forall with substitutor
+        void initWithSub( const FunctionType & o, Pass< ForallSubstitutor > & sub );
+public:
+        using ForallList = std::vector<ptr<TypeDecl>>;
         ForallList forall;
-        AssertionList assertions;
 
         std::vector<ptr<Type>> returns;
@@ -289 +292 @@
         : Type(q), returns(), params(), isVarArgs(va) {}
 
-        FunctionType( const FunctionType & o ) = default;
+        FunctionType( const FunctionType & o );
 
         /// true if either the parameters or return values contain a tttype
@@ -394 +397 @@
 public:
         readonly<TypeDecl> base;
-        // previously from renameTyVars; now directly use integer fields instead of synthesized strings
-        // a nonzero value of formal_usage indicates a formal type (only used in function type)
-        // a zero value of formal_usage indicates an actual type (referenced inside body of parametric structs and functions)
         TypeDecl::Kind kind;
-        int formal_usage = 0;
-        int expr_id = 0;
-
-        // compact representation used for map lookups.
-        struct TypeEnvKey { 
-                const TypeDecl * base;
-                int formal_usage;
-                int expr_id;
-
-                TypeEnvKey() = default;
-                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0): base(base), formal_usage(formal_usage), expr_id(expr_id) {}
-                TypeEnvKey(const TypeInstType & inst): base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
-                std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
-                bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
-
-        };
-
-        bool operator==(const TypeInstType & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
 
         TypeInstType(
@@ -427 +409 @@
         TypeInstType( const TypeInstType & o ) = default;
 
-        TypeInstType( const TypeEnvKey & key )
-        : BaseInstType(key.base->name), base(key.base), kind(key.base->kind), formal_usage(key.formal_usage), expr_id(key.expr_id) {}
-
         /// sets `base`, updating `kind` correctly
         void set_base( const TypeDecl * );
@@ -439 +418 @@
 
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
-
-        std::string typeString() const { 
-                if (formal_usage > 0) return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + name; 
-                else return name;
-        }
 private:
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
@@ -536 +510 @@
 
 bool isUnboundType(const Type * type);
-
-}
-
-namespace std {
-        template<>
-        struct hash<typename ast::TypeInstType::TypeEnvKey> {
-                size_t operator() (const ast::TypeInstType::TypeEnvKey & x) const {
-                        const size_t p = 1000007;
-                        size_t res = reinterpret_cast<size_t>(x.base);
-                        res = p * res + x.formal_usage;
-                        res = p * res + x.expr_id;
-                        return res;
-                } 
-        };
+bool isUnboundType(const std::string & tname);
+
 }