rdl 2.1.0 → 2.2.0

data/lib/rdl/types/rdl_types.rb

@@ -0,0 +1,45 @@
+RDL.type_params 'RDL::Type::SingletonType', [:t], :satisfies?
+
+RDL.type 'RDL::Type::SingletonType', :initialize, "(x) -> self<x>", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::SingletonType', :val, "() -> t", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::SingletonType', :nominal, "() -> RDL::Type::NominalType", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::NominalType', :initialize, "(Class or String) -> self", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::NominalType', :klass, "() -> Class", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::NominalType', :name, "() -> String", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::GenericType', :initialize, "(RDL::Type::Type, *RDL::Type::Type) -> self", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::GenericType', :params, "() -> Array<RDL::Type::Type>", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::GenericType', :base, "() -> RDL::Type::NominalType", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::UnionType', :initialize, "(*RDL::Type::Type) -> self", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::UnionType', :canonical, "() -> RDL::Type::Type", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::UnionType', :types, "() -> Array<RDL::Type::Type>", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::TupleType', :initialize, "(*RDL::Type::Type) -> self", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::TupleType', :params, "() -> Array<RDL::Type::Type>", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::TupleType', :promote, "(?RDL::Type::Type) -> RDL::Type::GenericType", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::TupleType', :promote!, "(?RDL::Type::Type) -> %bool", wrap: false, effect: [:-, :+]
+RDL.type 'RDL::Type::TupleType', :check_bounds, "(?%bool) -> %bool", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::FiniteHashType', :elts, "() -> Hash<%any, RDL::Type::Type>", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::FiniteHashType', :elts=, "(Hash<%any, RDL::Type::Type>) -> Hash<%any, RDL::Type::Type>", wrap: false, effect: [:-, :+]
+RDL.type 'RDL::Type::FiniteHashType', :promote, "(?%any, ?RDL::Type::Type) -> RDL::Type::GenericType", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::FiniteHashType', :promote!, "(?%any, ?RDL::Type::Type) -> %bool", wrap: false, effect: [:-, :+]
+RDL.type 'RDL::Type::FiniteHashType', :initialize, "(Hash<%any, RDL::Type::Type> or {}, ?RDL::Type::Type) -> self", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::FiniteHashType', :check_bounds, "(?%bool) -> %bool", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::OptionalType', :initialize, "(RDL::Type::Type) -> self", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::VarargType', :initialize, '(RDL::Type::Type) -> self', wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Type::VarType', :initialize, "(String) -> self", wrap: false, effect: [:+, :+]
+
+RDL.type "RDL::Type::Type", 'self.leq', "(RDL::Type::Type, RDL::Type::Type) -> %bool", wrap: false, effect: [:+, :+]
+
+RDL.type 'RDL::Globals', 'self.parser', "() -> RDL::Type::Parser", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Globals', 'self.types', "() -> Hash<Symbol, RDL::Type::Type>", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Type::Parser', :scan_str, "(String) -> RDL::Type::Type", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Config', 'self.instance', "() -> RDL::Config", wrap: false, effect: [:+, :+]
+RDL.type 'RDL::Config', 'weak_update_promote', "() -> %bool", wrap: false, effect: [:+, :+]
+RDL.type "Object", '__getobj__', "() -> self", wrap: false, effect: [:+, :+] ## needed due to type casting

data/lib/rdl/types/singleton.rb

@@ -1,6 +1,6 @@
 module RDL::Type
   class SingletonType < Type
-    attr_reader :val
+    attr_accessor :val
     attr_reader :nominal
 
     @@cache = {}
@@ -59,11 +59,24 @@ module RDL::Type
     def member?(obj, *args)
       t = RDL::Util.rdl_type obj
       return t <= self if t
+      return true if obj.nil?
       obj.equal?(@val)
     end
 
     def instantiate(inst)
       return self
     end
+
+    def widen
+      return self
+    end
+
+    def copy
+      return self
+    end
+
+    def satisfies?
+      yield(val)
+    end
   end
 end

data/lib/rdl/types/string.rb

@@ -0,0 +1,104 @@
+module RDL::Type
+  # A specialized precise type for Strings
+  class PreciseStringType < Type
+    attr_accessor :vals
+    attr_accessor :interp, :ubounds, :lbounds
+
+    ## @vals will be an array. For non-interpolated strings, it will only have one element, the string itself.
+    ## For interpolated strings, it will include strings and RDL types, in order, where the types represent
+    ## the types of the interpolated portions, and the strings represent the surrounding string parts.
+    def initialize(*vals)
+      @interp = false
+      vals.each { |v|
+        case v
+        when String
+          ## do nothing
+        when Type
+          ## interpolated string
+          @interp = true
+        else
+          raise RuntimeError, "Attempt to create precise string type with non-string or non-type value #{v}" unless vals.all? { |val| val.is_a?(Type) || val.is_a?(String) }
+        end
+      }
+      vals = [vals.join] if !@interp && vals.size > 1 ## if all elements of `vals` are strings, join them into one
+      
+      @vals = vals
+      @ubounds = []
+      @lbounds = []
+      @promoted = false
+      @cant_promote = false
+      super()
+    end
+
+    def canonical
+      return RDL::Globals.types[:string] if @promoted
+      return self
+    end
+
+    def to_s
+      return RDL::Globals.types[:string].to_s if @promoted
+      printed_vals = @vals.map { |v|
+        case v
+        when String
+          "'"+v+"'"
+        when Type
+          #'#{' + v.to_s.gsub('"',"'") + '}'
+          return "String"
+        end
+      }
+      return printed_vals.join
+    end
+
+    def ==(other)
+      return false if other.nil?
+      return RDL::Globals.types[:string] == other if @promoted
+      other = other.canonical
+      return (other.instance_of? PreciseStringType) && (other.vals == @vals)
+    end
+
+    def member?(obj, *args)
+      return false unless obj.is_a?(String)
+      raise "Checking membership of PreciseStringType not currently supported for interpolated strings." unless @vals.all? { |v| v.is_a?(String) }
+      return (@vals.join == obj)
+    end
+
+    def promote!
+      return false if @cant_promote
+      @promoted = true
+      check_bounds
+    end
+
+    def check_bounds
+      return (@lbounds.all? { |lbound| lbound <= self }) && (@ubounds.all? { |ubound| self <= ubound } )
+    end
+
+    def cant_promote!
+      raise RuntimeError, "already promoted!" if @promoted
+      @cant_promote = true
+    end
+
+    def <=(other, no_constraint=false)
+      return Type.leq(self, other, no_constraint: no_constraint)
+    end
+
+    def instantiate(inst)
+      return RDL::Globals.types[:string] if @promoted
+      @vals.map! { |v| if v.is_a?(Type) then v.instantiate(inst) else v end }
+      self
+    end
+
+    def widen
+      @vals.map! { |v| if v.is_a?(Type) then v.widen else v end }
+      self
+    end
+
+    def copy
+      return PreciseStringType.new(*@vals.map { |v| if v.is_a?(String) then v.clone else v.copy end })
+    end
+
+    def hash
+      99 * @vals.hash
+    end
+
+  end
+end

data/lib/rdl/types/structural.rb

@@ -47,6 +47,14 @@ module RDL::Type
       StructuralType.new(Hash[*@methods.each_pair.map { |m, t| [m, t.instantiate(inst)] }.flatten])
     end
 
+    def widen
+      StructuralType.new(Hash[*@methods.each_pair.map { |m, t| [m, t.widen] }.flatten])
+    end
+
+    def copy
+      StructuralType.new(Hash[*@methods.each_pair.map { |m, t| [m, t.copy] }.flatten])
+    end
+
     def ==(other)  # :nodoc:
       return false if other.nil?
       other = other.canonical

data/lib/rdl/types/top.rb

@@ -48,6 +48,14 @@ module RDL::Type
       return self
     end
 
+    def widen
+      return self
+    end
+
+    def copy
+      return self
+    end
+
     def hash
       17
     end

data/lib/rdl/types/tuple.rb

@@ -44,12 +44,23 @@ module RDL::Type
       return (other.instance_of? TupleType) && (@params.length == other.params.length) && (@params.zip(other.params).all? { |t,o| t.match(o) })
     end
 
-    def promote!
+    def promote(t=nil)
       return false if @cant_promote
-      @array = GenericType.new(RDL::Globals.types[:array], UnionType.new(*@params))
-      # note since we promoted this, lbounds and ubounds will be ignored in future constraints, which
-      # is good because otherwise we'd get infinite loops
-      return (@lbounds.all? { |lbound| lbound <= self }) && (@ubounds.all? { |ubound| self <= ubound })
+      param = UnionType.new(*@params, t)
+      param = param.widen if RDL::Config.instance.promote_widen
+      GenericType.new(RDL::Globals.types[:array], param)
+    end
+
+    ### TODO: similar question as in tuple types. Should [1,2,3] be promoted to Array<1 or 2 or 3> or Array<Integer>
+    def promote!(t=nil)
+      array = promote(t)
+      return false if !array
+      @array = array
+      check_bounds
+    end
+
+    def check_bounds(no_promote=false)
+      return (@lbounds.all? { |lbound|  lbound.<=(self, no_promote )}) && (@ubounds.all? { |ubound| self.<=(ubound, no_promote) })
     end
 
     def cant_promote!
@@ -57,8 +68,8 @@ module RDL::Type
       @cant_promote = true
     end
 
-    def <=(other)
-      return Type.leq(self, other)
+    def <=(other, no_constraint=false)
+      return Type.leq(self, other, no_constraint: no_constraint)
     end
 
     def member?(obj, *args)
@@ -71,7 +82,20 @@ module RDL::Type
 
     def instantiate(inst)
       return @array.instantiate(inst) if @array
-      return TupleType.new(*@params.map { |t| t.instantiate(inst) })
+      #return TupleType.new(*@params.map { |t| t.instantiate(inst) })
+      @params.map! { |t| t.instantiate(inst) }
+      self
+    end
+
+    def widen
+      return @array.widen if @array
+      #return TupleType.new(*@params.map { |t| t.widen })
+      @params.map! { |t| t.widen }
+      self
+    end
+
+    def copy
+      return TupleType.new(*@params.map { |t| t.copy })      
     end
 
     def hash

data/lib/rdl/types/type.rb

@@ -32,10 +32,11 @@ module RDL::Type
     # [+ other +] is a Type
     # [+ inst +] is a Hash<Symbol, Type> representing an instantiation
     # [+ ileft +] is a %bool
+    # [+ no_constraint +] is a %bool indicating whether or not we should add to tuple/FHT constraints
     # if inst is nil, returns self <= other
     # if inst is non-nil and ileft, returns inst(self) <= other, possibly mutating inst to make this true
     # if inst is non-nil and !ileft, returns self <= inst(other), again possibly mutating inst
-    def self.leq(left, right, inst=nil, ileft=true)
+    def self.leq(left, right, inst=nil, ileft=true, no_constraint: false)
       left = inst[left.name] if inst && ileft && left.is_a?(VarType) && inst[left.name]
       right = inst[right.name] if inst && !ileft && right.is_a?(VarType) && inst[right.name]
       left = left.type if left.is_a? DependentArgType
@@ -49,6 +50,10 @@ module RDL::Type
       return true if left.is_a? BotType
       return true if right.is_a? TopType
 
+      # dynamic
+      return true if left.is_a? DynamicType
+      return true if right.is_a? DynamicType
+
       # type variables
       begin inst.merge!(left.name => right); return true end if inst && ileft && left.is_a?(VarType)
       begin inst.merge!(right.name => left); return true end if inst && !ileft && right.is_a?(VarType)
@@ -72,12 +77,24 @@ module RDL::Type
 
       # nominal
       return left.klass.ancestors.member?(right.klass) if left.is_a?(NominalType) && right.is_a?(NominalType)
-      if left.is_a?(NominalType) && right.is_a?(StructuralType)
+      if (left.is_a?(NominalType) || left.is_a?(TupleType) || left.is_a?(FiniteHashType) || left.is_a?(PreciseStringType)) && right.is_a?(StructuralType)
+        case left
+        when TupleType
+          lklass = Array
+        when FiniteHashType
+          lklass = Hash
+        when PreciseStringType
+          lklass = String
+        else
+          lklass = left.klass
+        end
         right.methods.each_pair { |m, t|
-          return false unless left.klass.method_defined? m
-          types = RDL::Globals.info.get(left.klass, m, :type)
+          return false unless lklass.method_defined? m
+          types = RDL::Globals.info.get(lklass, m, :type)
           if types
-            return false unless types.all? { |tlm| leq(tlm, t, nil, ileft) }
+            non_dep_types = RDL::Typecheck.filter_comp_types(types, false)
+            raise "Need non-dependent types for method #{m} of class #{lklass} in order to use a structural type." if non_dep_types.empty?
+            return false unless non_dep_types.all? { |tlm| leq(tlm, t, nil, ileft) }
             # inst above is nil because the method types inside the class and
             # inside the structural type have an implicit quantifier on them. So
             # even if we're allowed to instantiate type variables we can't do that
@@ -98,7 +115,7 @@ module RDL::Type
         # do check here to avoid hiding errors if generic type written
         # with wrong number of parameters but never checked against
         # instantiated instances
-        raise TypeError, "No type parameters defined for #{base.name}" unless formals
+        raise TypeError, "No type parameters defined for #{left.base.name}" unless formals
         return false unless left.base == right.base
         return variance.zip(left.params, right.params).all? { |v, tl, tr|
           case v
@@ -116,7 +133,7 @@ module RDL::Type
       if left.is_a?(GenericType) && right.is_a?(StructuralType)
         # similar to logic above for leq(NominalType, StructuralType, ...)
         formals, variance, _ = RDL::Globals.type_params[left.base.name]
-        raise TypeError, "No type parameters defined for #{base.name}" unless formals
+        raise TypeError, "No type parameters defined for #{left.base.name}" unless formals
         base_inst = Hash[*formals.zip(left.params).flatten] # instantiation for methods in base's class
         klass = left.base.klass
         right.methods.each_pair { |meth, t|
@@ -162,8 +179,8 @@ module RDL::Type
         return false unless left.params.length == right.params.length
         return false unless left.params.zip(right.params).all? { |lt, rt| leq(lt, rt, inst, ileft) }
         # subyping check passed
-        left.ubounds << right
-        right.lbounds << left
+        left.ubounds << right unless no_constraint
+        right.lbounds << left unless no_constraint
         return true
       end
       if left.is_a?(TupleType) && right.is_a?(GenericType) && right.base == RDL::Globals.types[:array]
@@ -196,8 +213,8 @@ module RDL::Type
           # If left has optional stuff, right needs to accept it
           return false unless !(right.rest.nil?) && leq(left.rest, right.rest, inst, ileft)
         end
-        left.ubounds << right
-        right.lbounds << left
+        left.ubounds << right unless no_constraint
+        right.lbounds << left unless no_constraint
         return true
       end
       if left.is_a?(FiniteHashType) && right.is_a?(GenericType) && right.base == RDL::Globals.types[:hash]
@@ -206,6 +223,32 @@ module RDL::Type
         return leq(left, right, inst, ileft) # recheck for promoted type
       end
 
+      ## precise string
+      if left.is_a?(PreciseStringType)
+        if right.is_a?(PreciseStringType)
+          return false if left.vals.size != right.vals.size
+          left.vals.each_with_index { |v, i|
+            if v.is_a?(String) && right.vals[i].is_a?(String)
+              return false unless v == right.vals[i]
+            elsif v.is_a?(Type) && right.vals[i].is_a?(Type)
+              return false unless v <= right.vals[i]
+            else
+              return false
+            end
+          }
+          left.ubounds << right unless no_constraint
+          right.lbounds << left unless no_constraint
+          return true
+        elsif right == RDL::Globals.types[:string]
+          return false unless left.promote!
+          return true
+        elsif right.is_a?(NominalType) && String.ancestors.include?(RDL::Util.to_class(right.name))
+          ## necessary because of checking agains union types: we don't want to promote! unless it will work
+          left.promote!
+          return true
+        end
+      end
+
       return false
     end
   end

data/lib/rdl/types/union.rb

@@ -14,11 +14,11 @@ module RDL::Type
         if t.instance_of? UnionType
           ts.concat t.types
         else
-          raise RuntimeError, "Attempt to create union type with non-type" unless t.is_a? Type
+          raise RuntimeError, "Attempt to create union type with non-type" unless t.is_a?(Type) || t.nil?
           raise RuntimeError, "Attempt to create union with optional type" if t.is_a? OptionalType
           raise RuntimeError, "Attempt to create union with vararg type" if t.is_a? VarargType
           raise RuntimeError, "Attempt to create union with annotated type" if t.is_a? AnnotatedArgType
-          ts << t
+          ts << t if t
         end
       }
       return ts[0] if ts.size == 1
@@ -114,6 +114,45 @@ module RDL::Type
       return UnionType.new(*(@types.map { |t| t.instantiate(inst) }))
     end
 
+    def widen
+      return @canonical.widen if @canonical
+      sing_types = []
+      non_sing_types = []
+      @types.each { |t|
+        case t
+        when SingletonType
+          sing_types << t.nominal
+        when TupleType
+          sing_types << t.promote
+        when FiniteHashType
+          sing_types << t.promote
+        else
+          non_sing_types << t
+        end
+      }
+      UnionType.new(*sing_types, *non_sing_types).canonical
+    end
+
+    def copy
+      UnionType.new(*@types.map { |t| t.copy })
+    end
+=begin
+    def self.widened_type(u)
+      return u unless u.instance_of?(UnionType)
+      nominal_class = nil
+      @types.each { |t|
+        return u if !t.instance_of?(SingletonType)
+        if nominal_class.nil?
+          nominal_class = t.nominal ## first type
+        elsif nominal_class <= t.nominal
+          nominal_class = t.nominal ## update to more general class (or just stay the same)
+        else
+          return u ## found a case with differing singleton classes, can't widen
+        end
+      }
+      nominal_class
+    end
+=end
     def hash  # :nodoc:
       return @hash
     end