rdl 2.1.0 → 2.2.0

data/lib/rdl/types/annotated_arg.rb

@@ -41,6 +41,14 @@ module RDL::Type
       return AnnotatedArgType.new(@name, @type.instantiate(inst))
     end
 
+    def widen
+      return AnnotatedArgType.new(@name, @type.widen)
+    end
+
+    def copy
+      return AnnotatedArgType.new(@name, @type.copy)
+    end
+
     def optional?
       return type.optional?
     end

data/lib/rdl/types/ast_node.rb

@@ -0,0 +1,73 @@
+require 'pp'
+
+module RDL::Type
+  class AstNode < Type
+    attr_reader :op
+    attr_accessor  :val, :children, :parent
+
+    def initialize(op, val)
+      @op = op
+      @val = val
+      @children = []
+      @parent = nil
+    end
+
+    def root
+      unless self.parent
+        self
+      else
+        root(self.parent)
+      end
+    end
+
+    def insert(child)
+      raise "AstNode expected" unless child.is_a? AstNode
+      @children << child
+    end
+
+    def find_all(op)
+      @children.find_all { |obj| obj.op == op }
+    end
+
+    def find_one(op)
+      results = self.find_all(op)
+      raise "One node expected" unless results.size < 2
+      results[0]
+    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
+    end
+
+    def hash # :nodoc:
+      return @val.hash
+    end
+
+    def to_s
+      self.pretty_inspect
+    end
+
+    def <=(other)
+      return Type.leq(self, other)
+    end
+
+    def member?(obj, *args)
+      raise "member? on AstNode called"
+    end
+
+    def instantiate(inst)
+      return self
+    end
+  end
+end

data/lib/rdl/types/bot.rb

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

data/lib/rdl/types/bound_arg.rb

@@ -0,0 +1,63 @@
+require_relative 'type'
+
+module RDL::Type
+  class BoundArgType < Type
+    attr_reader :name
+    attr_reader :type
+
+    # Note: Named argument types aren't hashconsed.
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+      raise RuntimeError, "Attempt to create bound type with non-type" unless type.is_a? Type
+      raise RuntimeError, "Attempt to create doubly annotated type" if (type.is_a?(BoundArgType) || type.is_a?(AnnotatedArgType))
+      raise RuntimeError, "Cannot create bound type with optional type" if type.is_a? OptionalType
+      raise RuntimeError, "Cannot create bound type with variable argument type" if type.is_a? VarargType                                                                       
+      super()
+    end
+
+    def to_s
+      return "#{@name}<::#{@type.to_s}"
+    end
+
+    def ==(other) # :nodoc:
+      return false if other.nil?
+      other = other.canonical
+      return (other.instance_of? BoundArgType) && (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:
+      return (57 + @name.hash) * @type.hash
+    end
+
+    def member?(obj, *args)
+      @type.member?(obj, *args)
+    end
+
+    def instantiate(inst)
+      return BoundArgType.new(@name, @type.instantiate(inst))
+    end
+
+    def widen
+      return BoundArgType.new(@name, @type.widen)
+    end
+
+    def copy
+      return BoundArgType.new(@name, @type.copy)
+    end
+
+    def optional?
+      return type.optional?
+    end
+
+    def vararg?
+      return type.vararg?
+    end
+  end
+end
+

data/lib/rdl/types/computed.rb

@@ -0,0 +1,48 @@
+require_relative 'type'
+
+module RDL::Type
+  class ComputedType < Type
+    attr_reader :code
+
+    def initialize(code)
+      @code = code
+      super()
+    end
+
+    def compute(bind)
+      res = bind.eval(@code)
+      raise RuntimeError, "Expected ComputedType to evaluate to type, instead got #{res}." unless res.is_a?(Type)
+      res
+    end
+
+    def to_s
+      "``#{@code}``"
+    end
+
+    ### TODO:: Figure out how to fill in the below methods.
+    ### I believe a ComputedType will always be evaluated to
+    ### another RDL type before any of these methods would be called.
+    ### Need to think about this though.
+
+    def instantiate(inst)
+      @inst = inst
+      self
+    end
+
+    def widen
+      self
+    end
+    
+    def <=(other)
+      ## TODO
+    end
+
+    def ==(other)
+      ## TODO
+    end
+
+    alias eql? ==
+
+
+  end
+end

data/lib/rdl/types/dependent_arg.rb

@@ -52,5 +52,14 @@ module RDL::Type
     def instantiate(inst)
       return DependentArgType.new(@name, @type.instantiate(inst), @predicate)
     end
+
+    def widen
+      return DependentArgType.new(@name, @type.widen, @predicate)
+    end
+
+    def copy
+      return DependentArgType.new(@name, @type.copy, @predicate)
+    end
+
   end
 end

data/lib/rdl/types/dynamic.rb

@@ -0,0 +1,61 @@
+module RDL::Type
+  class DynamicType < Type
+    @@cache = nil
+
+    attr_reader :block
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new
+      @@cache = DynamicType.__new__ unless @@cache
+      return @@cache
+    end
+
+    def initialize
+      super
+    end
+
+    def to_s
+      "%dyn"
+    end
+
+    def ==(other)
+      return false if other.nil?
+      other = other.canonical
+      other.instance_of? DynamicType
+    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)
+      return Type.leq(self, other)
+    end
+
+    def member?(obj, *args)
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      true
+    end
+
+    def instantiate(inst)
+      return self
+    end
+
+    def copy
+      return self
+    end
+
+    def hash
+      16
+    end
+  end
+end

data/lib/rdl/types/finite_hash.rb

@@ -6,7 +6,7 @@ module RDL::Type
   # Finite hashes can also have a "rest" type (okay, they're not exactly finite in this case...)
   # which is treated as a hash from Symbol to the type.
   class FiniteHashType < Type
-    attr_reader :elts
+    attr_accessor :elts
     attr_reader :rest
     attr_reader :the_hash # either nil or hash type if self has been promoted to hash
     attr_accessor :ubounds  # upper bounds this tuple has been compared with using <=
@@ -58,18 +58,42 @@ module RDL::Type
               @elts.all? { |k, v| (other.elts.has_key? k) && (v.match(other.elts[k]))})
     end
 
-    def promote!
+    def promote(key=nil, value=nil)
       return false if @cant_promote
       # TODO look at key types
-      domain_type = UnionType.new(*(@elts.keys.map { |k| NominalType.new(k.class) }))
-      range_type = UnionType.new(*@elts.values)
+      if key
+        domain_type = UnionType.new(*(@elts.keys.map { |k| NominalType.new(k.class) }), key)
+      else
+        domain_type = UnionType.new(*(@elts.keys.map { |k| NominalType.new(k.class) }))
+      end
+      if value
+        range_type = UnionType.new(*@elts.values, value)
+      else
+        range_type = UnionType.new(*@elts.values)
+      end
       if @rest
         domain_type = UnionType.new(domain_type, RDL::Globals.types[:symbol])
         range_type = UnionType.new(range_type, @rest)
       end
-      @the_hash = GenericType.new(RDL::Globals.types[:hash], domain_type, range_type)
+      if RDL::Config.instance.promote_widen
+        case range_type
+        when RDL::Type::SingletonType
+          range_type = range_type.nominal if range_type.val
+        when RDL::Type::UnionType
+          range_type = range_type.widen
+        end
+      end
+      return GenericType.new(RDL::Globals.types[:hash], domain_type.canonical, range_type.canonical)
+    end
+
+    ### [+ key +] is type to add to promoted key types
+    ### [+ value +] is type to add to promoted value types
+    def promote!(key=nil, value=nil)
+      hash = promote(key, value)
+      return hash if !hash
+      @the_hash = hash
       # same logic as Tuple
-      return (@lbounds.all? { |lbound| lbound <= self }) && (@ubounds.all? { |ubound| self <= ubound })
+      return check_bounds
     end
 
     def cant_promote!
@@ -77,8 +101,12 @@ module RDL::Type
       @cant_promote = true
     end
 
-    def <=(other)
-      return Type.leq(self, other)
+    def check_bounds(no_promote=false)
+      return (@lbounds.all? { |lbound| lbound.<=(self, no_promote) }) && (@ubounds.all? { |ubound| self.<=(ubound, no_promote) })
+    end
+
+    def <=(other, no_constraint=false)
+      return Type.leq(self, other, no_constraint: no_constraint)
     end
 
     def member?(obj, *args)
@@ -87,6 +115,7 @@ module RDL::Type
       return t <= self if t
       right_elts = @elts.clone # shallow copy
 
+      return true if obj.nil?
       return false unless obj.instance_of? Hash
 
       # Check that every mapping in obj exists in @map and matches the type
@@ -111,7 +140,23 @@ module RDL::Type
 
     def instantiate(inst)
       return @the_hash.instantiate(inst) if @the_hash
-      return FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }], (if @rest then @rest.instantiate(inst) end))
+      #return FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }], (if @rest then @rest.instantiate(inst) end))
+      @elts = Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }]
+      @rest = @rest.instantiate(inst) if @rest
+      self
+    end
+
+    def widen
+      return @the_hash.widen if @the_hash
+      #return FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.widen] }], (if @rest then @rest.widen end))
+      @elts = Hash[@elts.map { |k, t| [k, t.widen] }]
+      @rest = @rest.widen if @rest
+      self
+    end
+
+    def copy
+      rest = @rest.copy if @rest
+      return FiniteHashType.new(Hash[@elts.map { |k,t| [k, t.copy] }], rest)
     end
 
     def hash

data/lib/rdl/types/generic.rb

@@ -40,6 +40,22 @@ module RDL::Type
     end
 
     def member?(obj, *args)
+      if base.name == "Table"
+        return true if obj.class.to_s == "Mocha::Mock" ## mock object class appearing in one of the benchmarks. Not much we can do here.
+        return false unless obj.class.ancestors.map { |a| a.to_s}.include?("Sequel::Dataset")#is_a?(Sequel::Dataset) (obj.class.to_s == "Sequel::SQLite::Dataset")
+        raise RDL::Type::TypeError, "Expected Table type to be parameterized by finite hash, instead got #{@params}." unless @params[0].is_a?(RDL::Type::FiniteHashType)
+        if @params[0].elts[:__all_joined].is_a?(RDL::Type::UnionType) && obj.joined_dataset?
+          type_joined_tables = @params[0].elts[:__all_joined].types.map { |t| t.val }
+          obj_joined_tables = obj.opts[:from] + obj.opts[:join].map { |t| t.table }
+          return (type_joined_tables.sort == obj_joined_tables.sort)
+        elsif !@params[0].elts[:__all_joined].is_a?(RDL::Type::TupleType) && !obj.joined_dataset?
+          return true
+        else
+          return false
+        end
+      elsif base.name == "ActiveRecord_Relation"
+        return (obj.class.name == "ActiveRecord::Relation" || obj.class.name == "ActiveRecord::Associations::CollectionProxy" || obj.class.name == "ActiveRecord::AssociationRelation") ## TODO: check for joins?
+      end
       raise "No type parameters defined for #{base.name}" unless RDL::Globals.type_params[base.name]
 #      formals = RDL::Globals.type_params[base.name][0]
       t = RDL::Util.rdl_type obj
@@ -52,6 +68,14 @@ module RDL::Type
       GenericType.new(base.instantiate(inst), *params.map { |t| t.instantiate(inst) })
     end
 
+    def widen
+      GenericType.new(base.widen, *params.map { |t| t.widen })
+    end
+
+    def copy
+      GenericType.new(base.copy, *params.map { |t| t.copy })
+    end
+
     def hash
       (61 + @base.hash) * @params.hash
     end
@@ -59,5 +83,14 @@ module RDL::Type
     def to_inst
       return RDL::Globals.type_params[base.name][0].zip(@params).to_h
     end
+
+    def canonical
+      canonicalize!
+      return self
+    end
+
+    def canonicalize!
+      @params.map! {|p| p.canonical}
+    end
   end
 end