rdl 1.1.1 → 2.0.0.rc1

data/lib/rdl/types/annotated_arg.rb

@@ -16,17 +16,17 @@ module RDL::Type
     end
 
     def to_s
-      "#{@type.to_s} #{@name}"
-    end
-
-    def eql?(other)
-      self == other
+      return "#{@type.to_s} #{@name}"
     end
 
     def ==(other) # :nodoc:
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? AnnotatedArgType) && (other.name == @name) && (other.type == @type)
     end
 
+    alias eql? ==
+
     # doesn't have a match method - queries shouldn't have annotations in them
 
     def hash # :nodoc:

data/lib/rdl/types/{nil.rb → bot.rb}

@@ -1,7 +1,5 @@
-require_relative 'type'
-
 module RDL::Type
-  class NilType < Type
+  class BotType < Type
     @@cache = nil
 
     class << self
@@ -9,7 +7,7 @@ module RDL::Type
     end
 
     def self.new
-      @@cache = NilType.__new__ unless @@cache
+      @@cache = BotType.__new__ unless @@cache
       return @@cache
     end
 
@@ -18,18 +16,17 @@ module RDL::Type
     end
 
     def to_s
-      "nil"
-    end
-
-    def eql?(other)
-      self == other
+      "%bot"
     end
 
     def ==(other)
-      other.instance_of? NilType
+      other.instance_of? BotType
     end
 
+    alias eql? ==
+
     def match(other)
+      other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
       return self == other
@@ -40,9 +37,8 @@ module RDL::Type
     end
 
     def member?(obj, *args)
-      t = RDL::Util.rdl_type obj
-      return t <= self if t
-      obj.nil?
+      # There are no values of this type (note nil does *not* have type %bot)
+      false
     end
 
     def instantiate(inst)

data/lib/rdl/types/dependent_arg.rb

@@ -19,17 +19,17 @@ module RDL::Type
     end
 
     def to_s
-      "#{@type.to_s} #{@name} {{#{@predicate}}}"
-    end
-
-    def eql?(other)
-      self == other
+      return "#{@type.to_s} #{@name} {{#{@predicate}}}"
     end
 
     def ==(other) # :nodoc:
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? DependentArgType) && (other.name == @name) && (other.type == @type)
     end
 
+    alias eql? ==
+
     # doesn't have a match method - queries shouldn't have annotations in them
 
     def hash # :nodoc:

data/lib/rdl/types/dots_query.rb

@@ -18,6 +18,8 @@ module RDL::Type
     end
 
     def ==(other)
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? DotsQuery)
     end
 

data/lib/rdl/types/finitehash.rb

@@ -6,19 +6,9 @@ module RDL::Type
   # to see if they match.
   class FiniteHashType < Type
     attr_reader :elts
-
-    @@cache = {}
-
-    class << self
-      alias :__new__ :new
-    end
-
-    def self.new(elts)
-      ct = @@cache[elts]
-      return ct if ct
-      t = FiniteHashType.__new__(elts)
-      return (@@cache[elts] = t) # assignment evaluates to t
-    end
+    attr_reader :the_hash # either nil or hash type if self has been promoted to hash
+    attr_reader :ubounds  # upper bounds this tuple has been compared with using <=
+    attr_reader :lbounds  # lower bounds...
 
     # [+elts+] is a map from keys to types
     def initialize(elts)
@@ -27,36 +17,85 @@ module RDL::Type
         raise RuntimeError, "Type may not be annotated or vararg" if (t.instance_of? AnnotatedArgType) || (t.instance_of? VarargType)
       }
       @elts = elts
+      @the_hash = nil
+      @cant_promote = false
+      @ubounds = []
+      @lbounds = []
       super()
     end
 
-    def to_s
-      "{" + @elts.map { |k, t| k.to_s + ": " + t.to_s }.join(', ') + "}"
+    def canonical
+      return @the_hash if @the_hash
+      return self
     end
 
-    def eql?(other)
-      self == other
+    def to_s
+      return @the_hash.to_s if @the_hash
+      "{" + @elts.map { |k, t| k.to_s + ": " + t.to_s }.join(', ') + "}"
     end
 
     def ==(other) # :nodoc:
+      return false if other.nil?
+      return (@the_hash == other) if @the_hash
+      other = other.canonical
       return (other.instance_of? FiniteHashType) && (other.elts == @elts)
     end
 
+    alias eql? ==
+
     def match(other)
+      return @the_hash.match(other) if @the_hash
+      other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
       return (@elts.length == other.elts.length &&
               @elts.all? { |k, v| (other.elts.has_key? k) && (v.match(other.elts[k]))})
     end
 
+    def promote!
+      return false if @cant_promote
+      @the_hash = GenericType.new($__rdl_hash_type, $__rdl_symbol_type, UnionType.new(*@elts.values))
+      # same logic as Tuple
+      return (@lbounds.all? { |lbound| lbound <= self }) && (@ubounds.all? { |ubound| self <= ubound })
+    end
+
+    def cant_promote!
+      raise RuntimeError, "already promoted!" if @the_hash
+      @cant_promote = true
+    end
+
     def <=(other)
+      return @the_hash <= other if @the_hash
+      other = other.canonical
       return true if other.instance_of? TopType
-      return self == other
-      # Subtyping with Hash not allowed
-      # All positions of HashTuple are invariant since tuples are mutable
+      other = other.the_hash if other.instance_of?(FiniteHashType) && other.the_hash
+      if other.instance_of? FiniteHashType
+        # Like Tuples, FiniteHashes are immutable, so covariant subtyping allowed
+        # But note, no width subtyping allowed, to match #member?
+        rest = other.elts.clone # shallow copy
+        @elts.each_pair { |k, tleft|
+          return false unless rest.has_key? k
+          tright = rest[k]
+          tleft = tleft.type if tleft.instance_of? OptionalType
+          tright = tright.type if tright.instance_of? OptionalType
+          return false unless tleft <= tright
+          rest.delete k
+        }
+        rest.each_pair { |k, tright|
+          return false unless tright.instance_of? OptionalType
+        }
+        ubounds << other
+        other.lbounds << self
+        return true
+      elsif (other.instance_of? GenericType) && (other.base == $__rdl_hash_type)
+        r = promote!
+        return (self <= other) && r
+      end
+      return false
     end
 
     def member?(obj, *args)
+      return @the_hash.member(obj, *args) if @the_hash
       t = RDL::Util.rdl_type obj
       return t <= self if t
       rest = @elts.clone # shallow copy
@@ -65,10 +104,10 @@ module RDL::Type
 
       # Check that every mapping in obj exists in @map and matches the type
       obj.each_pair { |k, v|
-        return false unless @elts.has_key?(k)
+        return false unless @elts.has_key? k
         t = @elts[k]
         t = t.type if t.instance_of? OptionalType
-        return false unless t.member?(v)
+        return false unless t.member? v
         rest.delete(k)
       }
 
@@ -76,14 +115,18 @@ module RDL::Type
       rest.each_pair { |k, vt|
         return false unless vt.instance_of? OptionalType
       }
+
+      return true
     end
 
     def instantiate(inst)
-      FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }])
+      return @the_hash.instantiate(inst) if @the_hash
+      return FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }])
     end
 
     def hash
-      229 * @elts.hash
+      # note don't change hash value if @the_hash becomes non-nil
+      return 229 * @elts.hash
     end
   end
 end

data/lib/rdl/types/generic.rb

@@ -7,23 +7,9 @@ module RDL::Type
     attr_reader :base
     attr_reader :params
 
-    @@cache = {}
-
-    class << self
-      alias :__new__ :new
-    end
-
-    def self.new(base, *params)
-      t = @@cache[[base, params]]
-      return t if t
+    def initialize(base, *params)
       raise RuntimeError, "Attempt to create generic type with non-type param" unless params.all? { |p| p.is_a? Type }
-      t = GenericType.__new__(base, params)
-      return (@@cache[[base, params]] = t) # assignment evaluates to t
-    end
-
-    def initialize(base, params)
       raise "base must be NominalType" unless base.instance_of? NominalType
-
       @base = base
       @params = params
       super()
@@ -33,21 +19,23 @@ module RDL::Type
       "#{@base}<#{@params.map { |t| t.to_s }.join(', ')}>"
     end
 
-    def eql?(other)
-      self == other
-    end
-
     def ==(other) # :nodoc:
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? GenericType) && (other.base == @base) && (other.params == @params)
     end
 
+    alias eql? ==
+
     def match(other)
+      other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
       return @params.length == other.params.length && @params.zip(other.params).all? { |t,o| t.match(o) }
     end
 
     def <=(other)
+      other = other.canonical
       formals, variance, _ = $__rdl_type_params[base.name]
       # do check here to avoid hiding errors if generic type written
       # with wrong number of parameters but never checked against
@@ -76,8 +64,8 @@ module RDL::Type
         k = base.klass
         other.methods.each_pair { |m, t|
           return false unless k.method_defined? m
-          if RDL::Wrap.has_contracts?(k, m, :type)
-            types = RDL::Wrap.get_contracts(k, m, :type)
+          types = $__rdl_info.get(k, m, :type)
+          if types
             return false unless types.all? { |t_self| t_self.instantiate(inst) <= t }
           end
         }
@@ -102,5 +90,9 @@ module RDL::Type
     def hash
       (61 + @base.hash) * @params.hash
     end
+
+    def to_inst
+      return $__rdl_type_params[base.name][0].zip(@params).to_h
+    end
   end
 end

data/lib/rdl/types/intersection.rb

@@ -13,7 +13,7 @@ module RDL::Type
     def self.new(*types)
       ts = []
       types.each { |t|
-        if t.instance_of? NilType
+        if t.nil_type?
           next
         elsif t.instance_of? IntersectionType
           ts.concat t.types
@@ -25,7 +25,7 @@ module RDL::Type
       ts.sort! { |a,b| a.object_id <=> b.object_id }
       ts.uniq!
 
-      return NilType.new if ts.size == 0
+      return $__rdl_nil_type if ts.size == 0
       return ts[0] if ts.size == 1
 
       t = @@cache[ts]
@@ -40,18 +40,19 @@ module RDL::Type
     end
 
     def to_s  # :nodoc:
-      "(#{@types.map { |t| t.to_s }.join(' and ')})"
-    end
-
-    def eql?(other)
-      self == other
+      return "(#{@types.map { |t| t.to_s }.join(' and ')})"
     end
 
     def ==(other)  # :nodoc:
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? IntersectionType) && (other.types == @types)
     end
 
+    alias eql? ==
+
     def match(other)
+      other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
       return false if @types.length != other.types.length
@@ -67,7 +68,7 @@ module RDL::Type
     end
 
     def hash  # :nodoc:
-      47 + @types.hash
+      return 47 + @types.hash
     end
   end
 end

data/lib/rdl/types/method.rb

@@ -1,5 +1,3 @@
-require_relative 'type'
-
 module RDL::Type
 
   # A type representing some method or block. MethodType has subcomponent
@@ -37,7 +35,7 @@ module RDL::Type
           state = :hash
         else
           raise "Attempt to create method type with non-type arg" unless arg.is_a? Type
-          raise "Required arguments not allowed after varargs" if state == :vararg
+#          raise "Required arguments not allowed after varargs" if state == :vararg # actually they are allowed!
           raise "Required arguments not allowed after named arguments" if state == :hash
         end
       }
@@ -52,27 +50,29 @@ module RDL::Type
       super()
     end
 
-    def le(other, h={})
-      raise RuntimeError, "should not be called"
-    end
-
     # TODO: Check blk
+    # Very similar to Typecheck.check_arg_types
     def pre_cond?(blk, slf, inst, bind, *args)
       states = [[0, 0]] # [position in @arg, position in args]
       preds = []
       until states.empty?
         formal, actual = states.pop
         if formal == @args.size && actual == args.size then # Matched all actuals, no formals left over
-	  check_arg_preds(bind, preds) if preds.size>0
-          @args.each_with_index {|a,i| args[i] = block_wrap(slf,inst,a,bind,&args[i]) if a.is_a?(RDL::Type::MethodType) }
-          blk = block_wrap(slf,inst,@block,bind,&blk) if @block
+	        check_arg_preds(bind, preds) if preds.size > 0
+          @args.each_with_index {|a,i| args[i] = block_wrap(slf, inst, a, bind, &args[i]) if a.is_a? MethodType }
+          if @block then
+            raise TypeError, "Expected method block of type {@block}, received no block." unless blk
+            blk = block_wrap(slf, inst, @block, bind, &blk)
+          elsif blk then
+            raise TypeError, "Block passed to method expecting no block."
+          end
           return [true, args, blk, bind]
         end
         next if formal >= @args.size # Too many actuals to match
         t = @args[formal]
         if t.instance_of? AnnotatedArgType then
-	  bind.local_variable_set(t.name.to_sym,args[actual])
-	  t = t.type
+	        bind.local_variable_set(t.name.to_sym,args[actual])
+	        t = t.type
         end
         case t
         when OptionalType
@@ -83,7 +83,7 @@ module RDL::Type
             states << [formal+1, actual+1] # match
             states << [formal+1, actual] # skip
           else
-            states << [formal+1, actual]  # type doesn't match; must skip this formal
+            states << [formal+1, actual]  # types don't match; must skip this formal
           end
         when VarargType
           t = t.type.instantiate(inst)
@@ -92,12 +92,12 @@ module RDL::Type
           elsif t.member?(args[actual], vars_wild: true)
             states << [formal, actual+1] # match, more varargs coming
             states << [formal+1, actual+1] # match, no more varargs
-#            states << [formal+1, actual] # skip - can't happen, varargs have to be at end
+            states << [formal+1, actual] # skip over even though matches
           else
-            states << [formal+1, actual] # skip
+            states << [formal+1, actual] # doesn't match, must skip
           end
         when DependentArgType
-	  bind.local_variable_set(t.name.to_sym,args[actual])
+	        bind.local_variable_set(t.name.to_sym,args[actual])
           preds.push(t)
           t = t.type.instantiate(inst)
           the_actual = nil
@@ -111,7 +111,7 @@ module RDL::Type
             # no else case; if there is no match, this is a dead end
           end
         else
-          t = RDL::Type::NominalType.new 'Proc' if t.instance_of? MethodType
+          t = NominalType.new 'Proc' if t.instance_of? MethodType
           t = t.instantiate(inst)
           the_actual = nil
           if actual == args.size
@@ -158,18 +158,18 @@ RUBY
 
     def post_cond?(slf, inst, ret, bind, *args)
       new_ret = ret
-      if @ret.is_a?(RDL::Type::MethodType) then
+      if @ret.is_a?(MethodType) then
         if !ret.is_a?(Proc) then
           return [false,ret]
         else
-	  new_ret = block_wrap(slf,inst,@ret,bind,&ret)
+	  new_ret = block_wrap(slf, inst, @ret, bind, &ret)
 	  return [true, new_ret]
 	end
       end
       method_name = method_name ? method_name + ": " : ""
-      if @ret.is_a?(DependentArgType) then
+      if @ret.is_a? DependentArgType then
         bind.local_variable_set(@ret.name.to_sym, ret)
-        check_ret_pred(bind,@ret)
+        check_ret_pred(bind, @ret)
       end
       return [@ret.instantiate(inst).member?(ret, vars_wild: true), new_ret]
     end
@@ -219,10 +219,10 @@ RUBY
       $__rdl_contract_switch.off {
         matches = [] # types that matched args
         types.each_with_index { |t, i|
-          res,args,blk,bind =t.pre_cond?(blk,slf,inst,bind,*args)
+          res, args, blk, bind = t.pre_cond?(blk, slf, inst, bind, *args)
           matches << i if res
-	}
-	return [matches, args, blk, bind] if matches.size > 0
+	      }
+	      return [matches, args, blk, bind] if matches.size > 0
         method_name = method_name ? method_name + ": " : ""
         raise TypeError, <<RUBY
 #{method_name}Argument type error.
@@ -284,10 +284,6 @@ RUBY
                             @ret.instantiate(inst))
     end
 
-    def eql?(other)
-      self == other
-    end
-
     # Return +true+ if +other+ is the same type
     def ==(other)
       return (other.instance_of? MethodType) &&
@@ -296,6 +292,8 @@ RUBY
         (other.ret == @ret)
     end
 
+    alias eql? ==
+
     # other may not be a query
     def match(other)
       other = other.type if other.instance_of? AnnotatedArgType
@@ -342,8 +340,8 @@ RUBY
 
     def self.check_block_arg_types(slf, types, inst, bind, *args)
       $__rdl_contract_switch.off {
-	res,args,blk,bind = types.pre_cond?(nil, slf, inst, bind, *args)
-	return [true, args,blk,bind] if res
+	      res,args,blk,bind = types.pre_cond?(nil, slf, inst, bind, *args)
+	      return [true, args, blk, bind] if res
         raise TypeError, <<RUBY
 Proc argument type error.
 Proc type:
@@ -358,8 +356,8 @@ RUBY
 
     def self.check_block_ret_types(slf, types, inst, ret, bind, *args)
       $__rdl_contract_switch.off {
-	res,new_ret = types.post_cond?(slf, inst, ret, bind, *args)
-	return new_ret if res
+	      res,new_ret = types.post_cond?(slf, inst, ret, bind, *args)
+	      return new_ret if res
         raise TypeError, <<RUBY
 Proc return type error.
 Proc type: