rdl 1.0.0.rc1

data/lib/rdl/types/generic.rb

@@ -0,0 +1,100 @@
+require_relative 'type'
+
+module RDL::Type
+  # A type that is parameterized on one or more other types. The base type
+  # must be a NominalType, while the parameters should be strings or symbols
+  class GenericType < 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
+      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()
+    end
+
+    def to_s
+      "#{@base}<#{@params.map { |t| t.to_s }.join(', ')}>"
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other) # :nodoc:
+      return (other.instance_of? GenericType) && (other.base == @base) && (other.params == @params)
+    end
+
+    def <=(other)
+      formals, variance, check = $__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
+      # instantiated instances
+      raise TypeError, "No type parameters defined for #{base.name}" unless formals
+      return true if other.instance_of? TopType
+#      return (@base <= other) if other.instance_of?(NominalType) # raw subtyping not allowed
+      if other.instance_of? GenericType
+        return false unless @base == other.base
+        return variance.zip(params, other.params).all? { |v, self_t, other_t|
+          case v
+          when :+
+            self_t <= other_t
+          when :-
+            other_t <= self_t
+          when :~
+            self_t == other_t
+          else
+            raise RuntimeError, "Unexpected variance #{v}" # shouldn't happen
+          end
+        }
+      end
+      if other.instance_of? StructuralType
+        # similar logic in NominalType
+        inst = Hash[*formals.zip(params).flatten]
+        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)
+            return false unless types.all? { |t_self| t_self.instantiate(inst) <= t }
+          end
+        }
+        return true
+      end
+      return false
+    end
+    
+    def member?(obj, *args)
+      raise "No type parameters defined for #{base.name}" unless $__rdl_type_params[base.name]
+      formals = $__rdl_type_params[base.name][0]
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      return false unless base.member?(obj, *args)
+      return true
+    end
+
+    def instantiate(inst)
+      GenericType.new(base, *params.map { |t| t.instantiate(inst) })
+    end
+    
+    def hash
+      h = (61 + @base.hash) * @params.hash
+    end
+  end
+end

data/lib/rdl/types/intersection.rb

@@ -0,0 +1,66 @@
+require_relative 'type'
+
+module RDL::Type
+  class IntersectionType < Type
+    attr_reader :types
+
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(*types)
+      ts = []
+      types.each { |t|
+        if t.instance_of? NilType
+          next
+        elsif t.instance_of? IntersectionType
+          ts.concat t.types
+        else
+          raise RuntimeError, "Attempt to create intersection 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 = IntersectionType.__new__(ts)
+      return (@@cache[ts] = t) # assignment evaluates to t
+    end
+
+    def initialize(types)
+      @types = types
+      super()
+    end
+
+    def to_s  # :nodoc:
+      "(#{@types.map { |t| t.to_s }.join(' and ')})"
+    end
+    
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)  # :nodoc:
+      return (other.instance_of? IntersectionType) && (other.types == @types)
+    end
+
+    def member?(obj, *args)
+      @types.all? { |t| t.member?(obj, *args) }
+    end
+    
+    def instantiate(inst)
+      return IntersectionType.new(*(@types.map { |t| t.instantiate(inst) }))
+    end
+    
+    def hash  # :nodoc:
+      47 + @types.hash
+    end
+  end
+end

data/lib/rdl/types/lexer.rex

@@ -0,0 +1,39 @@
+module RDL::Type
+class Parser
+
+macro
+  ID (\w|\:\:)+
+  SYMBOL :\w+
+  SPECIAL_ID %\w+
+  FIXNUM -?(\d)+
+  FLOAT -?\d\.\d+
+
+rule
+  \s            # skip
+  or            { [:OR, text] }
+  ->            { [:RARROW, text] }
+  =>            { [:RASSOC, text] }
+  \(            { [:LPAREN, text] }
+  \)            { [:RPAREN, text] }
+  \{            { [:LBRACE, text] }
+  \}            { [:RBRACE, text] }
+  \[            { [:LBRACKET, text] }
+  \]            { [:RBRACKET, text] }
+  <             { [:LESS, text] }
+  >             { [:GREATER, text] }
+  ,             { [:COMMA, text] }
+  \?            { [:QUERY, text] }
+  \*            { [:STAR, text] }
+  \#\#      	{ [:DOUBLE_HASH, text] }
+  \$\{          { [:CONST_BEGIN, text] }
+  {FLOAT}       { [:FLOAT, text] } # Must go before FIXNUM
+  {FIXNUM}      { [:FIXNUM, text] }
+  {ID}          { [:ID, text] }
+  {SYMBOL}      { [:SYMBOL, text[1..-1]] }
+  \:            { [:COLON, text] } # Must come after SYMBOL
+  {SPECIAL_ID}  { [:SPECIAL_ID, text] }
+  '[^']*'       { [:STRING, text.gsub("'", "")] }
+  "[^"]*"       { [:STRING, text.gsub('"', "")] }
+
+end
+end

data/lib/rdl/types/lexer.rex.rb

@@ -0,0 +1,148 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5
+# from lexical definition file "lexer.rex".
+#++
+
+require 'racc/parser'
+module RDL::Type
+class Parser < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+    
+    # skips empty actions
+    until token = _next_token or @ss.eos?; end
+    token
+  end
+
+  def _next_token
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/\s/))
+        ;
+
+      when (text = @ss.scan(/or/))
+         action { [:OR, text] }
+
+      when (text = @ss.scan(/->/))
+         action { [:RARROW, text] }
+
+      when (text = @ss.scan(/=>/))
+         action { [:RASSOC, text] }
+
+      when (text = @ss.scan(/\(/))
+         action { [:LPAREN, text] }
+
+      when (text = @ss.scan(/\)/))
+         action { [:RPAREN, text] }
+
+      when (text = @ss.scan(/\{/))
+         action { [:LBRACE, text] }
+
+      when (text = @ss.scan(/\}/))
+         action { [:RBRACE, text] }
+
+      when (text = @ss.scan(/\[/))
+         action { [:LBRACKET, text] }
+
+      when (text = @ss.scan(/\]/))
+         action { [:RBRACKET, text] }
+
+      when (text = @ss.scan(/</))
+         action { [:LESS, text] }
+
+      when (text = @ss.scan(/>/))
+         action { [:GREATER, text] }
+
+      when (text = @ss.scan(/,/))
+         action { [:COMMA, text] }
+
+      when (text = @ss.scan(/\?/))
+         action { [:QUERY, text] }
+
+      when (text = @ss.scan(/\*/))
+         action { [:STAR, text] }
+
+      when (text = @ss.scan(/\#\#/))
+         action { [:DOUBLE_HASH, text] }
+
+      when (text = @ss.scan(/\$\{/))
+         action { [:CONST_BEGIN, text] }
+
+      when (text = @ss.scan(/-?\d\.\d+/))
+         action { [:FLOAT, text] } # Must go before FIXNUM
+
+      when (text = @ss.scan(/-?(\d)+/))
+         action { [:FIXNUM, text] }
+
+      when (text = @ss.scan(/(\w|\:\:)+/))
+         action { [:ID, text] }
+
+      when (text = @ss.scan(/:\w+/))
+         action { [:SYMBOL, text[1..-1]] }
+
+      when (text = @ss.scan(/\:/))
+         action { [:COLON, text] } # Must come after SYMBOL
+
+      when (text = @ss.scan(/%\w+/))
+         action { [:SPECIAL_ID, text] }
+
+      when (text = @ss.scan(/'[^']*'/))
+         action { [:STRING, text.gsub("'", "")] }
+
+      when (text = @ss.scan(/"[^"]*"/))
+         action { [:STRING, text.gsub('"', "")] }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def _next_token
+
+end # class
+end

data/lib/rdl/types/method.rb

@@ -0,0 +1,219 @@
+require_relative 'type'
+
+module RDL::Type
+
+  # A type representing some method or block. MethodType has subcomponent
+  # types for arguments (zero or more), block (optional) and return value
+  # (exactly one).
+  class MethodType < Type
+    attr_reader :args
+    attr_reader :block
+    attr_reader :ret
+
+    @@contract_cache = {}
+    
+    # Create a new MethodType
+    #
+    # [+args+] List of types of the arguments of the procedure (use [] for no args).
+    # [+block+] The type of the block passed to this method, if it takes one.
+    # [+ret+] The type that the procedure returns.
+    def initialize(args, block, ret)
+      # First check argument types have form (any number of required
+      # or optional args, at most one vararg, any number of named arguments)
+      state = :required
+      args.each { |arg|
+        arg = arg.type if arg.instance_of? RDL::Type::AnnotatedArgType
+        case arg
+        when OptionalType
+          raise "Optional arguments not allowed after varargs" if state == :vararg
+          raise "Optional arguments not allowed after named arguments" if state == :hash
+          state = :optional
+        when VarargType
+          raise "Multiple varargs not allowed" if state == :vararg
+          raise "Varargs not allowed after named arguments" if state == :hash
+          state = :vararg
+        when FiniteHashType
+          raise "Only one set of named arguments allowed" if state == :hash
+          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 named arguments" if state == :hash
+        end
+      }
+      @args = *args
+
+      raise "Block must be MethodType" unless (not block) or (block.instance_of? MethodType)
+      @block = block
+
+      raise "Attempt to create method type with non-type ret" unless ret.is_a? Type
+      @ret = ret
+
+      super()
+    end
+
+    def le(other, h={})
+      raise RuntimeError, "should not be called"
+    end
+
+    # TODO: Check blk
+    def pre_cond?(inst, *args, &blk)
+      states = [[0, 0]] # [position in @arg, position in args]
+      until states.empty?
+        formal, actual = states.pop
+        return true if formal == @args.size && actual == args.size # Matched all actuals, no formals left over
+        next if formal >= @args.size # Too many actuals to match
+        t = @args[formal]
+        t = t.type if t.instance_of? AnnotatedArgType
+        case t
+        when OptionalType
+          t = t.type.instantiate(inst)
+          if actual == args.size
+            states << [formal+1, actual] # skip to allow extra formal optionals at end
+          elsif t.member?(args[actual], vars_wild: true)
+            states << [formal+1, actual+1] # match
+            states << [formal+1, actual] # skip
+          else
+            states << [formal+1, actual]  # type doesn't match; must skip this formal
+          end
+        when VarargType
+          t = t.type.instantiate(inst)
+          if actual == args.size
+            states << [formal+1, actual] # skip to allow empty vararg at end
+          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
+          else
+            states << [formal+1, actual] # skip
+          end
+        else
+          t = t.instantiate(inst)
+          the_actual = nil
+          if actual == args.size
+            next unless t.instance_of? FiniteHashType
+            if t.member?({}, vars_wild: true) # try matching against the empty hash
+              states << [formal+1, actual]
+            end
+          elsif t.member?(args[actual], vars_wild: true)
+            states << [formal+1, actual+1] # match
+            # no else case; if there is no match, this is a dead end
+          end
+        end
+      end
+      return false
+    end
+
+    def post_cond?(inst, ret, *args)
+      method_name = method_name ? method_name + ": " : ""
+      return @ret.instantiate(inst).member?(ret, vars_wild: true)
+    end
+
+    def to_contract(inst: nil)
+      c = @@contract_cache[self]
+      return c if c
+
+      # slf.ret, slf.args are the formals
+      # ret, args are the actuals
+      slf = self # Bind self so it's captured in a closure, since contracts are executed
+                 # with self bound to the receiver method's self
+      prec = RDL::Contract::FlatContract.new { |*args, &blk|
+        raise TypeError, "Arguments #{args} do not match argument types #{slf}" unless slf.pre_cond?(inst, *args, &blk)
+        true
+      }
+      postc = RDL::Contract::FlatContract.new { |ret, *args|
+        raise TypeError, "Return #{ret} does not match return type #{slf}" unless slf.post_cond?(inst, ret, *args)
+        true
+      }
+      c = RDL::Contract::ProcContract.new(pre_cond: prec, post_cond: postc)
+      return (@@contract_cache[self] = c) # assignment evaluates to c
+    end
+
+    # [+types+] is an array of method types. Checks that [+args+] and
+    # [+blk+] match at least one arm of the intersection type;
+    # otherwise raises exception. Returns array of method types that
+    # matched [+args+] and [+blk+]
+    def self.check_arg_types(method_name, types, inst, *args, &blk)
+      $__rdl_contract_switch.off {
+        matches = [] # types that matched args
+        types.each_with_index { |t, i| matches << i if t.pre_cond?(inst, *args, &blk) }
+        return matches if matches.size > 0
+        method_name = method_name ? method_name + ": " : ""
+        raise TypeError, <<RUBY
+#{method_name}Argument type error.
+Method type:
+#{ types.map { |t| "        " + t.to_s }.join("\n") }
+Actual argument type#{args.size > 1 ? "s" : ""}:
+        (#{args.map { |arg| RDL::Util.rdl_type_or_class(arg) }.join(', ')}) #{if blk then blk.to_s end}
+Actual argument values (one per line):
+#{ args.map { |arg| "        " + arg.inspect }.join("\n") }
+RUBY
+      }
+    end
+
+    def self.check_ret_types(method_name, types, inst, matches, ret, *args, &blk)
+      $__rdl_contract_switch.off {
+        matches.each { |i| return true if types[i].post_cond?(inst, ret, *args) }
+        method_name = method_name ? method_name + ": " : ""
+        raise TypeError, <<RUBY
+#{method_name}Return type error. *'s indicate argument lists that matched.
+Method type:
+#{types.each_with_index.map { |t,i| "       " + (matches.member?(i) ? "*" : " ") + t.to_s }.join("\n") }
+Actual return type:
+        #{ RDL::Util.rdl_type_or_class(ret)}
+Actual return value:
+        #{ ret.inspect }
+RUBY
+      }
+    end
+
+    def to_s  # :nodoc:
+      if @block
+        return "(#{@args.map { |arg| arg.to_s }.join(', ')}) {#{@block.to_s}} -> #{@ret.to_s}"
+      elsif @args
+        return "(#{@args.map { |arg| arg.to_s }.join(', ')}) -> #{@ret.to_s}"
+      else
+        return "() -> #{@ret.to_s}"
+      end
+    end
+
+    def <=(other)
+      return false unless other.instance_of? MethodType # only comparable to method types
+      return false unless other.args.size == @args.size
+      return false unless @args.zip(other.args).all? { |left, right| right <= left } # contravariance
+      return false unless @ret <= other.ret # covariance
+      if @block && other.block
+        return (other.block <= @block) # contravariance
+      elsif @block.nil? && other.block.nil?
+        return true
+      else
+        return false # one has a block and the other doesn't
+      end
+    end
+    
+    def instantiate(inst)
+      return MethodType.new(@args.map { |arg| arg.instantiate(inst) },
+                            @block ? @block.instantiate(inst) : nil,
+                            @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) &&
+        (other.args == @args) &&
+        (other.block == @block) &&
+        (other.ret == @ret)
+    end
+
+    def hash  # :nodoc:
+      h = (37 + @ret.hash) * 41 + @args.hash
+      h = h * 31 + @block.hash if @block
+      return h
+    end
+end
+end
+