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

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 {
@@ -272 +270 @@
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {
-        protected:
-        /// initializes forall with substitutor
-        void initWithSub( const FunctionType & o, Pass< ForallSubstitutor > & sub );
-public:
-        using ForallList = std::vector<ptr<TypeDecl>>;
+public:
+        using ForallList = std::vector<ptr<TypeInstType>>;
+        using AssertionList = std::vector<ptr<VariableExpr>>;
         ForallList forall;
+        AssertionList assertions;
 
         std::vector<ptr<Type>> returns;
@@ -292 +289 @@
         : Type(q), returns(), params(), isVarArgs(va) {}
 
-        FunctionType( const FunctionType & o );
+        FunctionType( const FunctionType & o ) = default;
 
         /// true if either the parameters or return values contain a tttype
@@ -397 +394 @@
 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(
@@ -409 +427 @@
         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 * );
@@ -418 +439 @@
 
         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 }; }
@@ -510 +536 @@
 
 bool isUnboundType(const Type * type);
-bool isUnboundType(const std::string & tname);
-
+
+}
+
+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;
+                } 
+        };
 }