rdl 1.1.1 → 2.0.0.rc1

data/lib/rdl/types/singleton.rb

@@ -1,8 +1,7 @@
-require_relative 'type'
-
 module RDL::Type
   class SingletonType < Type
     attr_reader :val
+    attr_reader :nominal
 
     @@cache = {}
     @@cache.compare_by_identity
@@ -20,17 +19,19 @@ module RDL::Type
 
     def initialize(val)
       @val = val
-    end
-
-    def eql?(other)
-      self == other
+      @nominal = NominalType.new(val.class)
     end
 
     def ==(other)
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? self.class) && (other.val.equal? @val)
     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
@@ -42,7 +43,9 @@ module RDL::Type
 
     def to_s
       if @val.instance_of? Symbol
-        ":{@val}"
+        ":#{@val}"
+      elsif @val.nil?
+        "nil"
       else
         @val.to_s
 #        "Singleton(#{@val.to_s})"
@@ -50,16 +53,18 @@ module RDL::Type
     end
 
     def <=(other)
+      other = other.canonical
       other.instance_of?(TopType) ||
+        (@val.nil? && (not (other.instance_of?(SingletonType)))) ||
         (other.instance_of?(SingletonType) && other.val == @val) ||
-        (other.instance_of?(NominalType) && @val.class == other.klass) ||
-        (other.instance_of?(NominalType) && @val.is_a?(other.klass))
+        (other.instance_of?(UnionType) && other.types.any? { |ot| self <= ot }) ||
+        (@nominal <= other)
     end
 
     def member?(obj, *args)
       t = RDL::Util.rdl_type obj
       return t <= self if t
-      obj.nil? || obj.equal?(@val)
+      obj.equal?(@val)
     end
 
     def instantiate(inst)

data/lib/rdl/types/structural.rb

@@ -1,5 +1,3 @@
-require_relative 'type'
-
 module RDL::Type
   class StructuralType < Type
     attr_reader :methods
@@ -36,6 +34,7 @@ module RDL::Type
     end
 
     def <=(other)
+      other = other.canonical
       return true if other.instance_of? TopType
       # in theory a StructuralType could contain all the methods of a NominalType or GenericType,
       # but it seems unlikely in practice, so disallow this case.
@@ -57,15 +56,16 @@ module RDL::Type
       StructuralType.new(Hash[*@methods.each_pair.map { |m, t| [m, t.instantiate(inst)] }.flatten])
     end
 
-    def eql?(other)
-      self == other
-    end
-
     def ==(other)  # :nodoc:
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? StructuralType) && (other.methods == @methods)
     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 (@methods.length == other.methods.length &&

data/lib/rdl/types/top.rb

@@ -1,5 +1,3 @@
-require_relative 'type'
-
 module RDL::Type
   class TopType < Type
     @@cache = nil
@@ -21,21 +19,23 @@ module RDL::Type
       "%any"
     end
 
-    def eql?(other)
-      self == other
-    end
-
     def ==(other)
+      return false if other.nil?
+      other = other.canonical
       other.instance_of? TopType
     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
     end
 
     def <=(other)
+      other = other.canonical
       other.instance_of? TopType
     end
 

data/lib/rdl/types/tuple.rb

@@ -1,55 +1,84 @@
-require_relative 'type'
-
 module RDL::Type
   # A specialized GenericType for tuples, i.e., fixed-sized arrays
   class TupleType < Type
     attr_reader :params
+    attr_reader :array   # either nil or array type if self has been promoted to array
+    attr_reader :ubounds # upper bounds this tuple has been compared with using <=
+    attr_reader :lbounds # lower bounds...
 
-    @@cache = {}
-
-    class << self
-      alias :__new__ :new
-    end
-
-    def self.new(*params)
-      t = @@cache[params]
-      return t if t
+    # no caching because array might be mutated
+    def initialize(*params)
       raise RuntimeError, "Attempt to create tuple type with non-type param" unless params.all? { |p| p.is_a? Type }
-      t = TupleType.__new__(params)
-      return (@@cache[params] = t) # assignment evaluates to t
-    end
-
-    def initialize(params)
       @params = params
+      @array = nil # emphasize initially this is a tuple, not an array
+      @cant_promote = false
+      @ubounds = []
+      @lbounds = []
       super()
     end
 
-    def to_s
-      "[#{@params.map { |t| t.to_s }.join(', ')}]"
+    def canonical
+      return @array if @array
+      return self
     end
 
-    def eql?(other)
-      self == other
+    def to_s
+      return @array.to_s if @array
+      return "[#{@params.map { |t| t.to_s }.join(', ')}]"
     end
 
     def ==(other) # :nodoc:
+      return false if other.nil?
+      return (@array == other) if @array
+      other = other.canonical
       return (other.instance_of? TupleType) && (other.params == @params)
     end
 
+    alias eql? ==
+
     def match(other)
+      return @array.match(other) if @array
+      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 promote!
+      return false if @cant_promote
+      @array = GenericType.new($__rdl_array_type, 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 })
+    end
+
+    def cant_promote!
+      raise RuntimeError, "already promoted!" if @array
+      @cant_promote = true
+    end
+
     def <=(other)
+      return @array <= other if @array
+      other = other.canonical
       return true if other.instance_of? TopType
-      return self == other
-      # Subtyping with Array not allowed
-      # All positions of Tuple are invariant since tuples are mutable
+      other = other.array if other.instance_of?(TupleType) && other.array
+      if other.instance_of? TupleType
+        # Tuples are immutable, so covariant subtyping allowed
+        return false unless @params.length == other.params.length
+        return false unless @params.zip(other.params).all? { |left, right| left <= right }
+        # subyping check passed
+        ubounds << other
+        other.lbounds << self
+        return true
+      elsif (other.instance_of? GenericType) && (other.base == $__rdl_array_type)
+        r = promote!
+        return (self <= other) && r
+      end
+      return false
     end
 
     def member?(obj, *args)
+      return @array.member?(obj, *args) if @array
       t = RDL::Util.rdl_type obj
       return t <= self if t
       return false unless obj.instance_of?(Array) && obj.size == @params.size
@@ -57,11 +86,14 @@ module RDL::Type
     end
 
     def instantiate(inst)
-      TupleType.new(*@params.map { |t| t.instantiate(inst) })
+      return @array.instantiate(inst) if @array
+      return TupleType.new(*@params.map { |t| t.instantiate(inst) })
     end
 
     def hash
+      # note don't change hash value if @array becomes non-nil
       73 * @params.hash
     end
+
   end
 end

data/lib/rdl/types/type.rb

@@ -20,5 +20,14 @@ module RDL::Type
       return (@@contract_cache[self] = c)  # assignment evaluates to c
     end
 
+    def nil_type?
+      is_a?(SingletonType) && @val.nil?
+    end
+
+    # default behavior, override in appropriate subclasses
+    def canonical
+      return self
+    end
+
   end
 end

data/lib/rdl/types/type_inferencer.rb

@@ -13,7 +13,7 @@ module RDL
       if current_types.size == 1
         current_types.to_a[0]
       elsif current_types.size == 0
-        RDL::Type::NilType.new
+        $__rdl_nil_type
       else
         RDL::Type::UnionType.new(*self.unify_param_types(current_types))
       end

data/lib/rdl/types/union.rb

@@ -1,61 +1,80 @@
-require_relative 'type'
-
 module RDL::Type
   class UnionType < Type
     attr_reader :types
 
-    @@cache = {}
-
     class << self
       alias :__new__ :new
     end
 
     def self.new(*types)
+      return $__rdl_nil_type if types.size == 0
       ts = []
+      # flatten nested unions, check that all args are types
       types.each { |t|
-        if t.instance_of? NilType
-          next
-        elsif t.instance_of? TopType
-          ts = [t]
-          break
-        elsif t.instance_of? UnionType
+        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
           ts << t
         end
       }
-
-      ts.sort! { |a,b| a.object_id <=> b.object_id }
-      ts.uniq!
-
-      return NilType.new if ts.size == 0
       return ts[0] if ts.size == 1
-
-      t = @@cache[ts]
-      return t if t
-      t = UnionType.__new__(ts)
-      return (@@cache[ts] = t) # assignment evaluates to t
+      return UnionType.__new__(ts)
     end
 
     def initialize(types)
       @types = types
+      @canonical = false
+      @canonicalized = false
+      @hash = 41 + @types.hash # don't rehash if @types changes
       super()
     end
 
-    def to_s  # :nodoc:
-      "#{@types.map { |t| t.to_s }.join(' or ')}"
+    def canonical
+      canonicalize!
+      return @canonical if @canonical
+      return self
     end
 
-    def eql?(other)
-      self == other
+    def canonicalize!
+      return if @canonicalized
+      # for any type such that a supertype is already in ts, set its position to nil
+      for i in 0..(@types.length-1)
+        for j in (i+1)..(@types.length-1)
+          next if (@types[j].nil?) || (@types[i].nil?)
+          (@types[i] = nil; break) if @types[i] <= @types[j]
+          (@types[j] = nil) if @types[j] <= @types[i]
+        end
+      end
+      @types.delete(nil) # eliminate any "deleted" elements
+      @types.sort! { |a, b| a.object_id <=> b.object_id } # canonicalize order
+      @types.uniq!
+      @canonical = @types[0] if @types.size == 1
+      @canonicalized = true
+    end
+
+    def to_s  # :nodoc:
+      return @canonical.to_s if @canonical
+      return "#{@types.map { |t| t.to_s }.join(' or ')}"
     end
 
     def ==(other)  # :nodoc:
-      return (other.instance_of? UnionType) && (other.types == @types)
+      return false if other.nil?
+      canonicalize!
+      return @canonical == other if @canonical
+      other = other.canonical
+      return false unless other.instance_of? UnionType
+      other.canonicalize!
+      return false unless @types.length == other.types.length
+      return @types.all? { |t| other.types.any? { |ot| t == ot } }
     end
 
+    alias eql? ==
+
     def match(other)
+      canonicalize!
+      return @canonical.match(other) if @canonical
+      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
@@ -63,19 +82,26 @@ module RDL::Type
     end
 
     def <=(other)
+      canonicalize!
+      return @canonical <= other if @canonical
+      other = other.canonical
       @types.all? { |t| t <= other }
     end
 
     def member?(obj, *args)
+      canonicalize!
+      return @canonical.member?(obj, *args) if @canonical
       @types.any? { |t| t.member?(obj, *args) }
     end
 
     def instantiate(inst)
+      canonicalize!
+      return @canonical.instantiate(inst) if @canonical
       return UnionType.new(*(@types.map { |t| t.instantiate(inst) }))
     end
 
     def hash  # :nodoc:
-      41 + @types.hash
+      return @hash
     end
   end
 end

data/lib/rdl/types/var.rb

@@ -1,5 +1,3 @@
-require_relative 'type'
-
 module RDL::Type
   class VarType < Type
     attr_reader :name
@@ -26,15 +24,18 @@ module RDL::Type
       return @name.to_s
     end
 
-    def eql?(other)
-      self == other
-    end
-
     def ==(other)
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? self.class) && (other.name.to_s == @name.to_s)
     end
 
+    alias eql? ==
+
+    alias <= == # hack to allow rdl_query to work with union types...
+
     def match(other)
+      other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
       return self == other

data/lib/rdl/types/vararg.rb

@@ -1,5 +1,3 @@
-require_relative 'type'
-
 module RDL::Type
   class VarargType < Type
     attr_reader :type
@@ -33,15 +31,16 @@ module RDL::Type
       end
     end
 
-    def eql?(other)
-      self == other
-    end
-
     def ==(other) # :nodoc:
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? VarargType) && (other.type == @type)
     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 (other.instance_of? VarargType) && (@type.match(other.type))