rdl 1.1.1 → 2.0.0.rc1

data/lib/rdl.rb

@@ -1,20 +1,27 @@
-require 'set'
 require 'delegate'
-require 'require_all'
+require 'digest'
+require 'set'
+require 'parser/current'
 
 module RDL
 end
 
-require_relative 'rdl/config.rb'
+require 'rdl/config.rb'
 def RDL.config
   yield(RDL::Config.instance)
 end
+require 'rdl/info.rb'
 
-# Hash from class name to method name to :pre/:post/:type to array of contracts
-# class names are strings (because they need to be manipulated in case they include ::)
-#  (class names may have Util.add_singleton_marker applied to them to indicate they're singleton classes.)
-# method names are symbols
-$__rdl_contracts = Hash.new
+# Method/variable info table with kinds:
+# For methods
+#   :pre to array of precondition contracts
+#   :post to array of postcondition contracts
+#   :type to array of types
+#   :source_location to [filename, linenumber] location of most recent definition
+#   :typecheck - boolean that is true if method should be statically type checked
+# For variables
+#   :type to type
+$__rdl_info = RDL::Info.new
 
 # Map from full_method_name to number of times called when wrapped
 $__rdl_wrapped_calls = Hash.new 0
@@ -32,26 +39,86 @@ $__rdl_aliases = Hash.new
 # method is a symbol
 $__rdl_to_wrap = Set.new
 
+# Same as $__rdl_to_wrap, but records [class, method] pairs to type check when they're defined
+$__rdl_to_typecheck_now = Set.new
+
 # List of contracts that should be applied to the next method definition
 $__rdl_deferred = []
 
 # Create switches to control whether wrapping happens and whether
 # contracts are checked. These need to be created before rdl/wrap.rb
 # is loaded.
-require_rel 'rdl/switch.rb'
+require 'rdl/switch.rb'
 $__rdl_wrap_switch = RDL::Switch.new
 $__rdl_contract_switch = RDL::Switch.new
 
-require_rel 'rdl/types/*.rb'
-require_rel 'rdl/contracts/*.rb'
-require_rel 'rdl/util.rb'
-require_rel 'rdl/wrap.rb'
-require_rel 'rdl/query.rb'
-#require_rel 'rdl/stats.rb'
+require 'rdl/types/type.rb'
+require 'rdl/types/annotated_arg.rb'
+require 'rdl/types/bot.rb'
+require 'rdl/types/dependent_arg.rb'
+require 'rdl/types/dots_query.rb'
+require 'rdl/types/finitehash.rb'
+require 'rdl/types/generic.rb'
+require 'rdl/types/intersection.rb'
+require 'rdl/types/lexer.rex.rb'
+require	'rdl/types/method.rb'
+require 'rdl/types/singleton.rb'
+require 'rdl/types/nominal.rb'
+require 'rdl/types/optional.rb'
+require 'rdl/types/parser.tab.rb'
+require 'rdl/types/structural.rb'
+require 'rdl/types/top.rb'
+require 'rdl/types/tuple.rb'
+require 'rdl/types/type_query.rb'
+require 'rdl/types/union.rb'
+require 'rdl/types/var.rb'
+require	'rdl/types/vararg.rb'
+require 'rdl/types/wild_query.rb'
+
+require 'rdl/contracts/contract.rb'
+require 'rdl/contracts/and.rb'
+require 'rdl/contracts/flat.rb'
+require 'rdl/contracts/or.rb'
+require 'rdl/contracts/proc.rb'
+
+require 'rdl/util.rb'
+require 'rdl/wrap.rb'
+require 'rdl/query.rb'
+require 'rdl/typecheck.rb'
+#require_relative 'rdl/stats.rb'
 
 $__rdl_parser = RDL::Type::Parser.new
 
+# Map from file names to [digest, cache] where 2nd elt maps
+#  :ast to the AST
+#  :line_defs maps linenumber to AST for def at that line
+$__rdl_ruby_parser_cache = Hash.new
+
+# Some generally useful types; not really a big deal to do this since
+# NominalTypes are cached, but these names are shorter to type
+$__rdl_nil_type = RDL::Type::NominalType.new NilClass # actually creates singleton type
+$__rdl_top_type = RDL::Type::TopType.new
+$__rdl_bot_type = RDL::Type::BotType.new
+$__rdl_object_type = RDL::Type::NominalType.new Object
+$__rdl_true_type = RDL::Type::NominalType.new TrueClass # actually creates singleton type
+$__rdl_false_type = RDL::Type::NominalType.new FalseClass # also singleton type
+$__rdl_bool_type = RDL::Type::UnionType.new($__rdl_true_type, $__rdl_false_type)
+$__rdl_fixnum_type = RDL::Type::NominalType.new Fixnum
+$__rdl_bignum_type = RDL::Type::NominalType.new Bignum
+$__rdl_float_type = RDL::Type::NominalType.new Float
+$__rdl_complex_type = RDL::Type::NominalType.new Complex
+$__rdl_rational_type = RDL::Type::NominalType.new Rational
+$__rdl_integer_type = RDL::Type::UnionType.new($__rdl_fixnum_type, $__rdl_bignum_type)
+$__rdl_numeric_type = RDL::Type::NominalType.new Numeric
+$__rdl_string_type = RDL::Type::NominalType.new String
+$__rdl_array_type = RDL::Type::NominalType.new Array
+$__rdl_hash_type = RDL::Type::NominalType.new Hash
+$__rdl_symbol_type = RDL::Type::NominalType.new Symbol
+$__rdl_range_type = RDL::Type::NominalType.new Range
+$__rdl_regexp_type = RDL::Type::NominalType.new Regexp
+$__rdl_standard_error_type = RDL::Type::NominalType.new StandardError
+
 # Hash from special type names to their values
-$__rdl_special_types = {'%any' => RDL::Type::TopType.new,
-                        '%bool' => RDL::Type::UnionType.new(RDL::Type::NominalType.new(TrueClass),
-                                                            RDL::Type::NominalType.new(FalseClass)) }
+$__rdl_special_types = {'%any' => $__rdl_top_type,
+                        '%bot' => $__rdl_bot_type,
+                        '%bool' => $__rdl_bool_type}

data/lib/rdl/info.rb

@@ -0,0 +1,74 @@
+class RDL::Info
+  # map from klass (String) to label (Symbol) to kind (Symbol) to either array or some other value
+  #
+  # class names are strings because they need to be manipulated in case they include ::
+  #  (class names may have Util.add_singleton_marker applied to them to indicate they're singleton classes.)
+
+  attr_accessor :info
+
+  def initialize
+    @info = Hash.new
+  end
+
+  # [+kind+] must map to an array
+  def add(klass, label, kind, val)
+    klass = klass.to_s
+    label = label.to_sym
+    @info[klass] = {} unless @info[klass]
+    @info[klass][label] = {} unless @info[klass][label]
+    @info[klass][label][kind] = [] unless @info[klass][label][kind]
+    @info[klass][label][kind] << val
+  end
+
+  # if no prev info for kind, set to val and return true
+  # if prev info for kind, return true if prev == val and false otherwise
+  def set(klass, label, kind, val)
+    klass = klass.to_s
+    label = label.to_sym
+    @info[klass] = {} unless @info[klass]
+    @info[klass][label] = {} unless @info[klass][label]
+    if @info[klass][label].has_key? kind
+      return (val == @info[klass][label][kind])
+    else
+      @info[klass][label][kind] = val
+      return true
+    end
+  end
+
+  # replace info for kind
+  def set!(klass, label, kind, val)
+    klass = klass.to_s
+    label = label.to_sym
+    @info[klass] = {} unless @info[klass]
+    @info[klass][label] = {} unless @info[klass][label]
+    @info[klass][label][kind] = val
+  end
+
+  def has?(klass, label, kind)
+    klass = klass.to_s
+    label = label.to_sym
+    return (@info.has_key? klass) &&
+           (@info[klass].has_key? label) &&
+           (@info[klass][label].has_key? kind)
+  end
+
+  def has_any?(klass, label, kinds)
+    klass = klass.to_s
+    label = label.to_sym
+    return (@info.has_key? klass) &&
+           (@info[klass].has_key? label) &&
+           (kinds.any? { |k| @info[klass][label].has_key? k })
+  end
+
+  # eventually replace with Hash#dig
+  def get(klass, label, kind)
+    klass = klass.to_s
+    label = label.to_sym
+    t1 = @info[klass]
+    return t1 if t1.nil?
+    t2 = t1[label]
+    return t2 if t2.nil?
+    return t2[kind]
+#    return @info[klass][label][kind]
+  end
+end

data/lib/rdl/query.rb

@@ -17,26 +17,25 @@ class RDL::Query
 #      klass = self.class.to_s
 #      meth = q.to_sym
     end
-    return nil unless RDL::Wrap.has_contracts?(klass, meth, :type)
-    return RDL::Wrap.get_contracts(klass, meth, :type)
+    return $__rdl_info.get(klass, meth, :type)
   end
 
   # Return an ordered list of all method types of a class. The query should be a class name.
   def self.class_query(q)
     klass = q.to_s
-    return nil unless $__rdl_contracts.has_key? klass
+    return nil unless $__rdl_info.info.has_key? klass
     cls_meths = []
     cls_klass = RDL::Util.add_singleton_marker(klass)
-    if $__rdl_contracts.has_key? cls_klass then
-      $__rdl_contracts[cls_klass].each { |meth, kinds|
+    if $__rdl_info.info.has_key? cls_klass then
+      $__rdl_info.info[cls_klass].each { |meth, kinds|
         if kinds.has_key? :type then
           kinds[:type].each { |t| cls_meths << [meth.to_s, t] }
         end
       }
     end
     inst_meths = []
-    if $__rdl_contracts.has_key? klass then
-      $__rdl_contracts[klass].each { |meth, kinds|
+    if $__rdl_info.info.has_key? klass then
+      $__rdl_info.info[klass].each { |meth, kinds|
         if kinds.has_key? :type then
           kinds[:type].each { |t| inst_meths << [meth.to_s, t] }
         end
@@ -52,12 +51,12 @@ class RDL::Query
   def self.method_type_query(q)
     q = $__rdl_parser.scan_str "#Q #{q}"
     result = []
-    $__rdl_contracts.each { |klass, meths|
+    $__rdl_info.info.each { |klass, meths|
       meths.each { |meth, kinds|
         if kinds.has_key? :type then
           kinds[:type].each { |t|
             if q.match(t)
-              result << [RDL::Util.pretty_name(klass, meth), t]
+              result << [RDL::Util.pp_klass_method(klass, meth), t]
             end
           }
         end

data/lib/rdl/typecheck.rb

@@ -0,0 +1,1057 @@
+module RDL::Typecheck
+
+  class StaticTypeError < StandardError; end
+
+  @@empty_hash_type = RDL::Type::FiniteHashType.new(Hash.new)
+  @@asgn_to_var = { lvasgn: :lvar, ivasgn: :ivar, cvasgn: :cvar, gvasgn: :gvar }
+
+  # Create mapping from file/line numbers to the def that appears at that location
+  class ASTMapper < AST::Processor
+    attr_accessor :line_defs
+
+    def initialize(file)
+      @file = file
+      @line_defs = Hash.new # map from line numbers to defs
+    end
+
+    def handler_missing(node)
+      node.children.each { |n| process n if n.is_a?(AST::Node) }
+    end
+
+    def on_def(node)
+      # (def name args body)
+      name, _, body = *node
+      if @line_defs[node.loc.line]
+        raise RuntimeError, "Multiple defs per line (#{name} and #{@line_defs[node.loc.line].children[1]} in #{@file}) currently not allowed"
+      end
+      @line_defs[node.loc.line] = node
+      process body
+      node.updated(nil, nil)
+    end
+
+    def on_defs(node)
+      # (defs (self) name args body)
+      _, name, _, body = *node
+      if @line_defs[node.loc.line]
+        raise RuntimeError, "Multiple defs per line (#{name} and #{@line_defs[node.loc.line].children[1]} in #{@file}) currently not allowed"
+      end
+      @line_defs[node.loc.line] = node
+      process body
+      node.updated(nil, nil)
+    end
+
+  end
+
+  # Local variable environment
+  # tracks the types of local variables, and whether they're "fixed," i.e.,
+  # whether they should be treated flow-insensitively
+  class Env
+    attr_accessor :env
+
+    # [+ params +] is a map from Symbols to Types. This initial variable mapping
+    # is added to the Env, and these initial mappings are fixed. If params
+    # is nil, initial Env is empty.
+    def initialize(params = nil)
+      @env = Hash.new
+      unless params.nil?
+        params.each_pair { |var, typ|
+          @env[var] = {type: typ, fixed: true}
+        }
+      end
+    end
+
+    # [+ var +] is a Symbol
+    def [](var)
+      return @env[var][:type]
+    end
+
+    def bind(var, typ)
+      raise RuntimeError, "Can't update variable with fixed type" if @env[var] && @env[var][:fixed]
+      result = Env.new
+      result.env = @env.merge(var => {type: typ, fixed: false})
+      return result
+    end
+
+    def has_key?(var)
+      return @env.has_key?(var)
+    end
+
+    def fix(var, typ)
+      raise RuntimeError, "Can't fix type of already-bound variable" if @env[var]
+      result = Env.new
+      result.env = @env.merge(var => {type: typ, fixed: true})
+      return result
+    end
+
+    def fixed?(var)
+      return @env[var] && @env[var][:fixed]
+    end
+
+    def ==(other)
+      return false unless other.is_a? Env
+      return @env == other.env
+    end
+
+    # merges bindings in self with bindings in other, preferring bindings in other if there is a common key
+    def merge(other)
+      result = Env.new
+      result.env = @env.merge(other.env)
+      return result
+    end
+
+    # [+ envs +] is Array<Env>
+    # any elts of envs that are nil are discarded
+    # returns new Env where every key is mapped to the union of its bindings in the envs
+    # any fixed binding in any env must be fixed in all envs and at the same type
+    def self.join(e, *envs)
+      raise RuntimeError, "Expecting AST, got #{e.class}" unless e.is_a? AST::Node
+      env = Env.new
+      envs.delete(nil)
+      return env if envs.empty?
+      return envs[0] if envs.size == 1
+      first = envs[0]
+      rest = envs[1..-1]
+      first.env.each_pair { |var, h|
+        first_typ = h[:type]
+        if h[:fixed]
+          error :inconsistent_var_type, [var.to_s], e unless rest.all? { |other| (other.fixed? var) || (not (other.has_key? var)) }
+          neq = []
+          rest.each { |other|
+            other_typ = other[var]
+            neq << other_typ unless first_typ == other_typ
+          }
+          error :inconsistent_var_type_type, [var.to_s, (first_typ + neq).map { |t| t.to_s }.join(' and ')], e unless neq.empty?
+          env.env[var] = {type: h[:type], fixed: true}
+        else
+          typ = RDL::Type::UnionType.new(first_typ, *rest.map { |other| ((other.has_key? var) && other[var]) || $__rdl_nil_type })
+          typ = typ.canonical
+          env.env[var] = {type: typ, fixed: false}
+        end
+      }
+      return env
+    end
+  end
+
+
+  # Call block with new Hash that is the same as Hash [+ scope +] except mappings in [+ elts +] have been merged.
+  # When block returns, copy out mappings in the new Hash to [+ scope +] except keys in [+ elts +].
+  def self.scope_merge(scope, **elts)
+    new_scope = scope.merge(**elts)
+    r = yield(new_scope)
+    new_scope.each_pair { |k,v|
+      scope[k] = v unless elts.has_key? k
+    }
+    return r
+  end
+
+  # report msg at ast's loc
+  def self.error(reason, args, ast)
+    raise StaticTypeError, ("\n" + (Parser::Diagnostic.new :error, reason, args, ast.loc.expression).render.join("\n"))
+  end
+
+  def self.typecheck(klass, meth)
+    file, line = $__rdl_info.get(klass, meth, :source_location)
+    raise RuntimeError, "static type checking in irb not supported" if file == "(irb)"
+    digest = Digest::MD5.file file
+    cache_hit = (($__rdl_ruby_parser_cache.has_key? file) &&
+                 ($__rdl_ruby_parser_cache[file][0] == digest))
+    unless cache_hit
+      file_ast = Parser::CurrentRuby.parse_file file
+      mapper = ASTMapper.new(file)
+      mapper.process(file_ast)
+      cache = {ast: file_ast, line_defs: mapper.line_defs}
+      $__rdl_ruby_parser_cache[file] = [digest, cache]
+    end
+    ast = $__rdl_ruby_parser_cache[file][1][:line_defs][line]
+    raise RuntimeError, "Can't find source for class #{RDL::Util.pp_klass_method(klass, meth)}" if ast.nil?
+    types = $__rdl_info.get(klass, meth, :type)
+    raise RuntimeError, "Can't typecheck method with no types?!" if types.nil? or types == []
+
+    if ast.type == :def
+      name, args, body = *ast
+    elsif ast.type == :defs
+      _, name, args, body = *ast
+    else
+      raise RuntimeError, "Unexpected ast type #{ast.type}"
+    end
+    raise RuntimeError, "Method #{name} defined where method #{meth} expected" if name.to_sym != meth
+    types.each { |type|
+      # TODO will need fancier logic here for matching up more complex arg lists
+      if RDL::Util.has_singleton_marker(klass)
+        # to_class gets the class object itself, so remove singleton marker to get class rather than singleton class
+        self_type = RDL::Type::SingletonType.new(RDL::Util.to_class(RDL::Util.remove_singleton_marker(klass)))
+      else
+        self_type = RDL::Type::NominalType.new(klass)
+      end
+      inst = {self: self_type}
+      type = type.instantiate inst
+      error :arg_count_mismatch, ['method', type.args.length, 'method', args.children.length], args unless type.args.length == args.children.length
+      a = args.children.map { |arg| arg.children[0] }.zip(type.args).to_h
+      a[:self] = self_type
+      scope = {tret: type.ret, tblock: type.block }
+      _, body_type = if body.nil? then [nil, $__rdl_nil_type] else tc(scope, Env.new(a), body) end
+      error :bad_return_type, [body_type.to_s, type.ret.to_s], body unless body.nil? || body_type <= type.ret
+    }
+  end
+
+  # The actual type checking logic.
+  # [+ scope +] tracks flow-insensitive information about the current scope, excluding local variables
+  # [+ env +] is the (local variable) Env
+  # [+ e +] is the expression to type check
+  # Returns [env', t], where env' is the type environment at the end of the expression
+  # and t is the type of the expression. t is always canonical.
+  def self.tc(scope, env, e)
+    case e.type
+    when :nil
+      [env, $__rdl_nil_type]
+    when :true
+      [env, $__rdl_true_type]
+    when :false
+      [env, $__rdl_false_type]
+    when :complex, :rational, :str, :string # constants
+      [env, RDL::Type::NominalType.new(e.children[0].class)]
+    when :int, :float, :sym # singletons
+      [env, RDL::Type::SingletonType.new(e.children[0])]
+    when :dstr, :xstr # string (or execute-string) with interpolation
+      envi = env
+      e.children.each { |ei| envi, _ = tc(scope, envi, ei) }
+      [envi, $__rdl_string_type]
+    when :dsym # symbol with interpolation
+      envi = env
+      e.children.each { |ei| envi, _ = tc(scope, envi, ei) }
+      [envi, $__rdl_symbol_type]
+    when :regexp
+      envi = env
+      e.children.each { |ei| envi, _ = tc(scope, envi, ei) unless ei.type == :regopt }
+      [envi, $__rdl_regexp_type]
+    when :array
+      envi = env
+      tis = []
+      is_array = false
+      e.children.each { |ei|
+        if ei.type == :splat
+          envi, ti = tc(scope, envi, ei.children[0]);
+          if ti.is_a? RDL::Type::TupleType
+            ti.cant_promote! # must remain a tuple
+            tis.concat(ti.params)
+          elsif ti.is_a? RDL::Type::FiniteHashType
+            ti.cant_promote! # must remain a finite hash
+            ti.elts.each_pair { |k, t|
+              tis << RDL::Type::TupleType.new(RDL::Type::SingletonType.new(k), t)
+            }
+          elsif ti.is_a?(RDL::Type::GenericType) && ti.base == $__rdl_array_type
+            is_array = true
+            tis << ti.params[0]
+          elsif ti.is_a?(RDL::Type::GenericType) && ti.base == $__rdl_hash_type
+            is_array = true
+            tis << RDL::Type::TupleType.new(*ti.params)
+          elsif ti.is_a?(RDL::Type::SingletonType) && ti.val.nil?
+            # nil gets thrown out
+          elsif ($__rdl_array_type <= ti) || (ti <= $__rdl_array_type) ||
+                ($__rdl_hash_type <= ti) || (ti <= $__rdl_hash_type)
+            # might or might not be array...can't splat...
+            error :cant_splat, [ti], ei
+          else
+            tis << ti # splat does nothing
+          end
+        else
+          envi, ti = tc(scope, envi, ei);
+          tis << ti
+        end
+      }
+      if is_array
+        [envi, RDL::Type::GenericType.new($__rdl_array_type, RDL::Type::UnionType.new(*tis).canonical)]
+      else
+        [envi, RDL::Type::TupleType.new(*tis)]
+      end
+    when :hash
+      envi = env
+      tlefts = []
+      trights = []
+      is_fh = true
+      e.children.each { |p|
+        # each child is a pair
+        if p.type == :pair
+          envi, tleft = tc(scope, envi, p.children[0])
+          tlefts << tleft
+          envi, tright = tc(scope, envi, p.children[1])
+          trights << tright
+          is_fh = false unless tleft.is_a?(RDL::Type::SingletonType)
+        elsif p.type == :kwsplat
+          envi, tkwsplat = tc(scope, envi, p.children[0])
+          if tkwsplat.is_a? RDL::Type::FiniteHashType
+            tkwsplat.cant_promote! # must remain finite hash
+            tlefts.concat(tkwsplat.elts.keys.map { |k| RDL::Type::SingletonType.new(k) })
+            trights.concat(tkwsplat.elts.values)
+          elsif tkwsplat.is_a?(RDL::Type::GenericType) && tkwsplat.base == $__rdl_hash_type
+            is_fh = false
+            tlefts << tkwsplat.params[0]
+            trights << tkwsplat.params[1]
+          else
+            error :cant_splat, [tkwsplat], p
+          end
+        else
+          raise "Don't know what to do with #{p.type}"
+        end
+      }
+      if is_fh
+        # keys are all symbols
+        fh = tlefts.map { |t| t.val }.zip(trights).to_h
+        [envi, RDL::Type::FiniteHashType.new(fh)]
+      else
+        tleft = RDL::Type::UnionType.new(*tlefts)
+        tright = RDL::Type::UnionType.new(*trights)
+        [envi, RDL::Type::GenericType.new($__rdl_hash_type, tleft, tright)]
+      end
+      #TODO test!
+#    when :kwsplat # TODO!
+    when :irange, :erange
+      env1, t1 = tc(scope, env, e.children[0])
+      env2, t2 = tc(scope, env1, e.children[1])
+      # promote singleton types to nominal types; safe since Ranges are immutable
+      t1 = RDL::Type::NominalType.new(t1.val.class) if t1.is_a? RDL::Type::SingletonType
+      t2 = RDL::Type::NominalType.new(t2.val.class) if t2.is_a? RDL::Type::SingletonType
+      error :nonmatching_range_type, [t1, t2], e if t1 != t2
+      [env2, RDL::Type::GenericType.new($__rdl_range_type, t1)]
+    when :self
+      [env, env[:self]]
+    when :lvar, :ivar, :cvar, :gvar
+      tc_var(scope, env, e.type, e.children[0], e)
+    when :lvasgn, :ivasgn, :cvasgn, :gvasgn
+      x = e.children[0]
+      # if local var, lhs is bound to nil before assignment is executed! only matters in type checking for locals
+      env = env.bind(x, $__rdl_nil_type) if ((e.type == :lvasgn) && (not (env.has_key? x)))
+      envright, tright = tc(scope, env, e.children[1])
+      tc_vasgn(scope, envright, e.type, x, tright, e)
+    when :masgn
+      # (masgn (mlhs (Xvasgn var-name) ... (Xvasgn var-name)) rhs)
+      e.children[0].children.each { |asgn|
+        next unless asgn.type == :lvasgn
+        x = e.children[0]
+        env = env.bind(x, $__rdl_nil_type) if (not (env.has_key? x)) # see lvasgn
+        # Note don't need to check outer_env here because will be checked by tc_vasgn below
+      }
+      envi, tright = tc(scope, env, e.children[1])
+      lhs = e.children[0].children
+      if tright.is_a? RDL::Type::TupleType
+        tright.cant_promote! # must always remain a tuple because of the way type checking currently works
+        rhs = tright.params
+        splat_ind = lhs.index { |lhs_elt| lhs_elt.type == :splat }
+        if splat_ind
+          if splat_ind > 0
+            lhs[0..splat_ind-1].each { |left|
+              # before splat
+              error :masgn_bad_lhs, [], left if rhs.empty?
+              envi, _ = tc_vasgn(scope, envi, left.type, left.children[0], rhs.shift, left)
+            }
+          end
+          lhs[splat_ind+1..-1].reverse_each { |left|
+            # after splat
+            error :masgn_bad_lhs, [], left if rhs.empty?
+            envi, _ = tc_vasgn(scope, envi, left.type, left.children[0], rhs.pop, left)
+          }
+          splat = lhs[splat_ind]
+          envi, _ = tc_vasgn(scope, envi, splat.children[0].type, splat.children[0].children[0], RDL::Type::TupleType.new(*rhs), splat)
+          [envi, tright]
+        else
+          error :masgn_num, [rhs.length, lhs.length], e unless lhs.length == rhs.length
+          lhs.zip(rhs).each { |left, right|
+            envi, _ = tc_vasgn(scope, envi, left.type, left.children[0], right, left)
+          }
+          [envi, tright]
+        end
+      elsif (tright.is_a? RDL::Type::GenericType) && (tright.base == $__rdl_array_type)
+        tasgn = tright.params[0]
+        lhs.each { |asgn|
+          if asgn.type == :splat
+            envi, _ = tc_vasgn(scope, envi, asgn.children[0].type, asgn.children[0].children[0], tright, asgn)
+          else
+            envi, _ = tc_vasgn(scope, envi, asgn.type, asgn.children[0], tasgn, asgn)
+          end
+        }
+        [envi, tright]
+      else
+        error :masgn_bad_rhs, [tright], e.children[1]
+      end
+    when :op_asgn
+      if e.children[0].type == :send
+        # (op-asgn (send recv meth) :op operand)
+        meth = e.children[0].children[1]
+        envleft, trecv = tc(scope, env, e.children[0].children[0]) # recv
+        tloperand = tc_send(scope, envleft, trecv, meth, [], nil, e.children[0]) # call recv.meth()
+        envoperand, troperand = tc(scope, envleft, e.children[2]) # operand
+        tright = tc_send(scope, envoperand, tloperand, e.children[1], [troperand], nil, e) # recv.meth().op(operand)
+        mutation_meth = (meth.to_s + '=').to_sym
+        tres = tc_send(scope, envoperand, trecv, mutation_meth, [tright], nil, e) # call recv.meth=(recv.meth().op(operand))
+        [envoperand, tres]
+      else
+        # (op-asgn (Xvasgn var-name) :op operand)
+        x = e.children[0].children[0] # Note don't need to check outer_env here because will be checked by tc_vasgn below
+        env = env.bind(x, $__rdl_nil_type) if ((e.children[0].type == :lvasgn) && (not (env.has_key? x))) # see :lvasgn
+        envi, trecv = tc_var(scope, env, @@asgn_to_var[e.children[0].type], x, e.children[0]) # var being assigned to
+        envright, tright = tc(scope, envi, e.children[2]) # operand
+        trhs = tc_send(scope, envright, trecv, e.children[1], [tright], nil, e)
+        tc_vasgn(scope, envright, e.children[0].type, x, trhs, e)
+      end
+    when :and_asgn, :or_asgn
+      # very similar logic to op_asgn
+      if e.children[0].type == :send
+        meth = e.children[0].children[1]
+        envleft, trecv = tc(scope, env, e.children[0].children[0]) # recv
+        tleft = tc_send(scope, envleft, trecv, meth, [], nil, e.children[0]) # call recv.meth()
+        envright, tright = tc(scope, envleft, e.children[1]) # operand
+      else
+        x = e.children[0].children[0] # Note don't need to check outer_env here because will be checked by tc_var below
+        env = env.bind(x, $__rdl_nil_type) if ((e.children[0].type == :lvasgn) && (not (env.has_key? x))) # see :lvasgn
+        envleft, tleft = tc_var(scope, env, @@asgn_to_var[e.children[0].type], x, e.children[0]) # var being assigned to
+        envright, tright = tc(scope, envleft, e.children[1])
+      end
+      envi, trhs = (if tleft.is_a? RDL::Type::SingletonType
+                      if e.type == :and_asgn
+                        if tleft.val then [envright, tright] else [envleft, tleft] end
+                      else # e.type == :or_asgn
+                        if tleft.val then [envleft, tleft] else [envright, tright] end
+                      end
+                    else
+                      [Env.join(e, envleft, envright), RDL::Type::UnionType.new(tleft, tright).canonical]
+                    end)
+      if e.children[0].type == :send
+        mutation_meth = (meth.to_s + '=').to_sym
+        tres = tc_send(scope, envi, trecv, mutation_meth, [trhs], nil, e)
+        [envi, tres]
+      else
+        tc_vasgn(scope, envi, e.children[0].type, x, trhs, e)
+      end
+    when :nth_ref, :back_ref
+      [env, $__rdl_string_type]
+    when :const
+      c = nil
+      if e.children[0].nil?
+        c = env[:self].klass.const_get(e.children[1])
+      elsif e.children[0].type == :cbase
+        raise "const cbase not implemented yet" # TODO!
+      elsif e.children[0].type == :lvar
+        raise "const lvar not implemented yet" # TODO!
+      else
+        raise "const other not implemented yet"
+      end
+      case c
+      when TrueClass, FalseClass, Complex, Rational, Fixnum, Bignum, Float, Symbol, Class
+        [env, RDL::Type::SingletonType.new(c)]
+      else
+        [env, RDL::Type::NominalType.new(const_get(e.children[1]).class)]
+      end
+    when :defined?
+      # do not type check subexpression, since it may not be type correct, e.g., undefined variable
+      [env, $__rdl_string_type]
+    when :send, :csend
+      # children[0] = receiver; if nil, receiver is self
+      # children[1] = method name, a symbol
+      # children [2..] = actual args
+      return tc_var_type(scope, env, e) if e.children[1] == :var_type && e.children[0].nil? && scope[:block].nil?
+      return tc_type_cast(scope, env, e) if e.children[1] == :type_cast && scope[:block].nil?
+      envi = env
+      tactuals = []
+      block = scope[:block]
+      scope_merge(scope, block: nil) { |sscope|
+        e.children[2..-1].each { |ei|
+          if ei.type == :splat
+            envi, ti = tc(sscope, envi, ei.children[0])
+            if ti.is_a? RDL::Type::TupleType
+              tactuals.concat ti.params
+            elsif ti.is_a?(RDL::Type::GenericType) && ti.base == $__rdl_array_type
+              tactuals << RDL::Type::VarargType.new(ti)
+            else
+              error :cant_splat, [ti], ei.children[0]
+            end
+          else
+            envi, ti = tc(sscope, envi, ei)
+            tactuals << ti
+          end
+        }
+        envi, trecv = if e.children[0].nil? then [envi, envi[:self]] else tc(sscope, envi, e.children[0]) end # if no receiver, self is receiver
+        [envi, tc_send(sscope, envi, trecv, e.children[1], tactuals, block, e).canonical]
+      }
+    when :yield
+      # very similar to send except the callee is the method's block
+      error :no_block, [], e unless scope[:tblock]
+      error :block_block, [], e if scope[:tblock].block
+      scope[:exn] = Env.join(e, scope[:exn], env) if scope.has_key? :exn # assume this call might raise an exception
+      envi = env
+      tactuals = []
+      e.children[0..-1].each { |ei| envi, ti = tc(scope, envi, ei); tactuals << ti }
+      unless tc_arg_types(scope[:tblock], tactuals)
+        msg = <<RUBY
+      Block type: #{scope[:tblock]}
+Actual arg types: (#{tactuals.map { |ti| ti.to_s }.join(', ')})
+RUBY
+        msg.chomp! # remove trailing newline
+        error :block_type_error, [msg], e
+      end
+      [envi, scope[:tblock].ret]
+      # tblock
+    when :block
+      # (block send block-args block-body)
+      scope_merge(scope, block: [e.children[1], e.children[2]]) { |bscope|
+        tc(bscope, env, e.children[0])
+      }
+    when :and, :or
+      envleft, tleft = tc(scope, env, e.children[0])
+      envright, tright = tc(scope, envleft, e.children[1])
+      if tleft.is_a? RDL::Type::SingletonType
+        if e.type == :and
+          if tleft.val then [envright, tright] else [envleft, tleft] end
+        else # e.type == :or
+          if tleft.val then [envleft, tleft] else [envright, tright] end
+        end
+      else
+        [Env.join(e, envleft, envright), RDL::Type::UnionType.new(tleft, tright).canonical]
+      end
+    # when :not # in latest Ruby, not is a method call that could be redefined, so can't count on its behavior
+    #   a1, t1 = tc(scope, a, e.children[0])
+    #   if t1.is_a? RDL::Type::SingletonType
+    #     if t1.val then [a1, $__rdl_false_type] else [a1, $__rdl_true_type] end
+    #   else
+    #     [a1, $__rdl_bool_type]
+    #   end
+    when :if
+      envi, tguard = tc(scope, env, e.children[0]) # guard; any type allowed
+      # always type check both sides
+      envleft, tleft = if e.children[1].nil? then [envi, $__rdl_nil_type] else tc(scope, envi, e.children[1]) end # then
+      envright, tright = if e.children[2].nil? then [envi, $__rdl_nil_type] else tc(scope, envi, e.children[2]) end # else
+      if tguard.is_a? RDL::Type::SingletonType
+        if tguard.val then [envleft, tleft] else [envright, tright] end
+      else
+        [Env.join(e, envleft, envright), RDL::Type::UnionType.new(tleft, tright).canonical]
+      end
+    when :case
+      envi = env
+      envi, tcontrol = tc(scope, envi, e.children[0]) unless e.children[0].nil? # the control expression, which make be nil
+      # for each guard, invoke guard === control expr, then possibly do body, possibly short-circuiting arbitrary later stuff
+      tbodies = []
+      envbodies = []
+      e.children[1..-2].each { |wclause|
+        raise RuntimeError, "Don't know what to do with case clause #{wclause.type}" unless wclause.type == :when
+        envguards = []
+        wclause.children[0..-2].each { |guard| # first wclause.length-1 children are the guards
+          envi, tguard = tc(scope, envi, guard) # guard type can be anything
+          tc_send(scope, envi, tguard, :===, [tcontrol], nil, guard) unless tcontrol.nil?
+          envguards << envi
+        }
+        envbody, tbody = tc(scope, Env.join(e, *envguards), wclause.children[-1]) # last wclause child is body
+        tbodies << tbody
+        envbodies << envbody
+      }
+      if e.children[-1].nil?
+        # no else clause, might fall through having missed all cases
+        envbodies << envi
+      else
+        # there is an else clause
+        envelse, telse = tc(scope, envi, e.children[-1])
+        tbodies << telse
+        envbodies << envelse
+      end
+      return [Env.join(e, *envbodies), RDL::Type::UnionType.new(*tbodies).canonical]
+    when :while, :until
+      # break: loop exit, i.e., right after loop guard; may take argument
+      # next: before loop guard; argument not allowed
+      # retry: not allowed
+      # redo: after loop guard, which is same as break
+      env_break, _ = tc(scope, env, e.children[0]) # guard can have any type, may exit after checking guard
+      scope_merge(scope, break: env_break, tbreak: $__rdl_nil_type, next: env, redo: env_break) { |lscope|
+        begin
+          old_break = lscope[:break]
+          old_next = lscope[:next]
+          old_tbreak = lscope[:tbreak]
+          if e.children[1]
+            env_body, _ = tc(lscope, lscope[:break], e.children[1]) # loop runs
+            lscope[:next] = Env.join(e, lscope[:next], env_body)
+          end
+          env_guard, _ = tc(lscope, lscope[:next], e.children[0]) # then guard runs
+          lscope[:break] = lscope[:redo] = Env.join(e, lscope[:break], lscope[:redo], env_guard)
+        end until old_break == lscope[:break] && old_next == lscope[:next] && old_tbreak == lscope[:tbreak]
+        [lscope[:break], lscope[:tbreak].canonical]
+      }
+    when :while_post, :until_post
+      # break: loop exit; note may exit loop before hitting guard once; maybe take argument
+      # next: before loop guard; argument not allowed
+      # retry: not allowed
+      # redo: beginning of body, which is same as after guard, i.e., same as break
+      scope_merge(scope, break: nil, tbreak: $__rdl_nil_type, next: nil, redo: nil) { |lscope|
+        if e.children[1]
+          env_body, _ = tc(lscope, env, e.children[1])
+          lscope[:next] = Env.join(e, lscope[:next], env_body)
+        end
+        begin
+          old_break = lscope[:break]
+          old_next = lscope[:next]
+          old_tbreak = lscope[:tbreak]
+          env_guard, _ = tc(lscope, lscope[:next], e.children[0])
+          lscope[:break] = lscope[:redo] = Env.join(e, lscope[:break], lscope[:redo], env_guard)
+          if e.children[1]
+            env_body, _ = tc(lscope, lscope[:break], e.children[1])
+            lscope[:next] = Env.join(e, lscope[:next], env_body)
+          end
+        end until old_break == lscope[:break] && old_next == lscope[:next] && old_tbreak == lscope[:tbreak]
+        [lscope[:break], lscope[:tbreak].canonical]
+      }
+    when :for
+      # break: loop exit, which is same as top of body, arg allowed
+      # next: top of body, arg allowed
+      # retry: not allowed
+      # redo: top of body
+      raise RuntimeError, "Loop variable #{e.children[0]} in for unsupported" unless e.children[0].type == :lvasgn
+      # TODO: mlhs in e.children[0]
+      x  = e.children[0].children[0] # loop variable
+      if scope[:outer_env] && (scope[:outer_env].has_key? x) && (not (scope[:outer_env].fixed? x))
+        error :nonlocal_access, [x], e.children[0]
+      end
+      envi, tcollect = tc(scope, env, e.children[1]) # collection to iterate through
+      teaches = nil
+      tcollect = tcollect.canonical
+      case tcollect
+      when RDL::Type::NominalType
+        teaches = lookup(tcollect.name, :each, e.children[1])
+      when RDL::Type::GenericType, RDL::Type::TupleType, RDL::Type::FiniteHashType
+        unless tcollect.is_a? RDL::Type::GenericType
+          error :tuple_finite_hash_promote, (if tcollect.is_a? RDL::Type::TupleType then ['tuple', 'Array'] else ['finite hash', 'Hash'] end), e.children[1] unless tcollect.promote!
+          tcollect = tcollect.canonical
+        end
+        teaches = lookup(tcollect.base.name, :each, e.children[1])
+        inst = tcollect.to_inst.merge(self: tcollect)
+        teaches = teaches.map { |t| t.instantiate(inst) }
+      else
+        error :for_collection, [tcollect], e.children[1]
+      end
+      teach = nil
+      teaches.each { |t|
+        # find `each` method with right type signature:
+        #    () { (t1) -> t2 } -> t3
+        next unless t.args.empty?
+        next if t.block.nil?
+        next unless t.block.args.size == 1
+        next unless t.block.block.nil?
+        teach = t
+        break
+      }
+      error :no_each_type, [tcollect.name], e.children[1] if teach.nil?
+      envi = envi.bind(x, teach.block.args[0])
+      scope_merge(scope, break: envi, next: envi, redo: envi, tbreak: teach.ret, tnext: envi[x])  { |lscope|
+        # could exit here
+        # if the loop always exits via break, then return type will come only from break, and otherwise the
+        # collection is returned. But it's hard to tell statically if there are only exits via break, so
+        # conservatively assume that at least the collection is returned.
+        begin
+          old_break = lscope[:break]
+          old_tbreak = lscope[:tbreak]
+          old_tnext = lscope[:tnext]
+          if e.children[2]
+            lscope[:break] = lscope[:break].bind(x, lscope[:tnext])
+            env_body, _ = tc(lscope, lscope[:break], e.children[2])
+            lscope[:break] = lscope[:next] = lscope[:redo] = Env.join(e, lscope[:break], lscope[:next], lscope[:redo], env_body)
+          end
+        end until old_break == lscope[:break] && old_tbreak == lscope[:tbreak] && old_tnext == lscope[:tnext]
+        [lscope[:break], lscope[:tbreak].canonical]
+      }
+    when :break, :redo, :next, :retry
+      error :kw_not_allowed, [e.type], e unless scope.has_key? e.type
+      if e.children[0]
+        tkw_name = ('t' + e.type.to_s).to_sym
+        error :kw_arg_not_allowed, [e.type], e unless scope.has_key? tkw_name
+        env, tkw = tc(scope, env, e.children[0])
+        scope[tkw_name] = RDL::Type::UnionType.new(scope[tkw_name], tkw)
+      end
+      scope[e.type] = Env.join(e, scope[e.type], env)
+      [env, $__rdl_bot_type]
+    when :return
+      # TODO return in lambda returns from lambda and not outer scope
+      env1, t1 = tc(scope, env, e.children[0])
+      error :bad_return_type, [t1.to_s, scope[:tret]], e unless t1 <= scope[:tret]
+      [env1, $__rdl_bot_type] # return is a void value expression
+    when :begin, :kwbegin # sequencing
+      envi = env
+      ti = nil
+      e.children.each { |ei| envi, ti = tc(scope, envi, ei) }
+      [envi, ti]
+    when :ensure
+      # (ensure main-body ensure-body)
+      # TODO exception control flow from main-body, vars initialized to nil
+      env_body, tbody = tc(scope, env, e.children[0])
+      env_ensure, _ = tc(scope, env_body, e.children[1])
+      [env_ensure, tbody] # value of ensure not returned
+    when :rescue
+      # (rescue main-body resbody1 resbody2 ... (else else-body))
+      # resbodyi, else optional
+      # local variables assigned to in main-body will all be initialized to nil even if an exception
+      # is raised during main-body's execution before those varibles are assigned to.
+      # similarly, local variables assigned in resbody will be initialized to nil even if the resbody
+      # is never triggered
+      scope_merge(scope, retry: env, exn: nil) { |rscope|
+        begin
+          old_retry = rscope[:retry]
+          env_body, tbody = tc(rscope, rscope[:retry], e.children[0])
+          tres = [tbody] # note throw away inferred types from previous iterations---should be okay since should be monotonic
+          env_res = [env_body]
+          if rscope[:exn]
+            e.children[1..-2].each { |resbody|
+              env_resbody, tresbody = tc(rscope, rscope[:exn], resbody)
+              tres << tresbody
+              env_res << env_resbody
+            }
+            if e.children[-1]
+              env_else, telse = tc(rscope, rscope[:exn], e.children[-1])
+              tres << telse
+              env_res << env_else
+            end
+          end
+        end until old_retry == rscope[:retry]
+        # TODO: variables newly bound in *env_res should be unioned with nil
+        [Env.join(e, *env_res), RDL::Type::UnionType.new(*tres).canonical]
+      }
+    when :resbody
+      # (resbody (array exns) (lvasgn var) rescue-body)
+      envi = env
+      texns = []
+      if e.children[0]
+        e.children[0].children.each { |exn|
+          envi, texn = tc(scope, envi, exn)
+          error :exn_type, [], exn unless texn.is_a?(RDL::Type::SingletonType) && texn.val.is_a?(Class)
+          texns << RDL::Type::NominalType.new(texn.val)
+        }
+      else
+        texns = [$__rdl_standard_error_type]
+      end
+      if e.children[1]
+        envi, _ = tc_vasgn(scope, envi, :lvasgn, e.children[1].children[0], RDL::Type::UnionType.new(*texns), e.children[1])
+      end
+      tc(scope, envi, e.children[2])
+    else
+      raise RuntimeError, "Expression kind #{e.type} unsupported"
+    end
+  end
+
+  # [+ kind +] is :lvar, :ivar, :cvar, or :gvar
+  # [+ name +] is the variable name, which should be a symbol
+  # [+ e +] is the expression for which errors should be reported
+  def self.tc_var(scope, env, kind, name, e)
+    case kind
+    when :lvar  # local variable
+      error :undefined_local_or_method, [name], e unless env.has_key? name
+      if scope[:outer_env] && (scope[:outer_env].has_key? name) && (not (scope[:outer_env].fixed? name))
+        error :nonlocal_access, [name], e
+      end
+      [env, env[name].canonical]
+    when :ivar, :cvar, :gvar
+      klass = (if kind == :gvar then RDL::Util::GLOBAL_NAME else env[:self] end)
+      unless $__rdl_info.has?(klass, name, :type)
+        kind_text = (if kind == :ivar then "instance"
+                     elsif kind == :cvar then "class"
+                     else "global" end)
+        error :untyped_var, [kind_text, name], e
+      end
+      [env, $__rdl_info.get(klass, name, :type).canonical]
+    else
+      raise RuntimeError, "unknown kind #{kind}"
+    end
+  end
+
+  # Same arguments as tc_var except
+  # [+ tright +] is type of right-hand side
+  def self.tc_vasgn(scope, env, kind, name, tright, e)
+    case kind
+    when :lvasgn
+      if scope[:outer_env] && (scope[:outer_env].has_key? name) && (not (scope[:outer_env].fixed? name))
+        error :nonlocal_access, [name], e
+      end
+      if env.fixed? name
+        error :vasgn_incompat, [tright, env[name]], e unless tright <= env[name]
+        [env, tright.canonical]
+      else
+        [env.bind(name, tright), tright.canonical]
+      end
+    when :ivasgn, :cvasgn, :gvasgn
+      klass = (if kind == :gvasgn then RDL::Util::GLOBAL_NAME else env[:self] end)
+      unless $__rdl_info.has?(klass, name, :type)
+        kind_text = (if kind == :ivasgn then "instance"
+                    elsif kind == :cvasgn then "class"
+                    else "global" end)
+        error :untyped_var, [kind_text, name], e
+      end
+      tleft = $__rdl_info.get(klass, name, :type)
+      error :vasgn_incompat, [tright.to_s, tleft.to_s], e unless tright <= tleft
+      [env, tright.canonical]
+    when :send
+      meth = e.children[1] # note method name include =!
+      envi, trecv = tc(scope, env, e.children[0]) # receiver
+      # name is not useful here
+      [envi, tc_send(scope, envi, trecv, meth, [tright], nil, e)] # call receiver.meth(tright)
+    else
+      raise RuntimeError, "unknown kind #{kind}"
+    end
+  end
+
+  # [+ e +] is the method call
+  def self.tc_var_type(scope, env, e)
+    error :var_type_format, [], e unless e.children.length == 4
+    var = e.children[2].children[0] if e.children[2].type == :sym
+    error :var_type_format, [], e.children[2] if var.nil? || (not (var =~ /^[a-z]/))
+    typ_str = e.children[3].children[0] if (e.children[3].type == :str) || (e.children[3].type == :string)
+    error :var_type_format, [], e.children[3] if typ_str.nil?
+    begin
+      typ = $__rdl_parser.scan_str("#T " + typ_str)
+    rescue Racc::ParseError => err
+      error :generic_error, [err.to_s[1..-1]], e.children[3] # remove initial newline
+    end
+    [env.fix(var, typ), $__rdl_nil_type]
+  end
+
+  def self.tc_type_cast(scope, env, e)
+    error :type_cast_format, [], e unless e.children.length <= 4
+    typ_str = e.children[2].children[0] if (e.children[2].type == :str) || (e.children[2].type == :string)
+    error :type_cast_format, [], e.children[2] if typ_str.nil?
+    begin
+      typ = $__rdl_parser.scan_str("#T " + typ_str)
+    rescue Racc::ParseError => err
+      error :generic_error, [err.to_s[1..-1]], e.children[2] # remove initial newline
+    end
+    if e.children[3]
+      fh = e.children[3]
+      error :type_cast_format, [], fh unless fh.type == :hash && fh.children.length == 1
+      pair = fh.children[0]
+      error :type_cast_format, [], fh unless pair.type == :pair && pair.children[0].type == :sym && pair.children[0].children[0] == :force
+      force_arg = pair.children[1]
+      env1, _ = tc(scope, env, force_arg)
+    end
+    [env1, typ]
+  end
+
+  # Type check a send
+  # [+ scope +] is the scope; used only for checking block arguments
+  # [+ env +] is the environment; used only for checking block arguments.
+  #   Note locals from blocks args don't escape, so no env is returned.
+  # [+ trecvs +] is the type of the recevier
+  # [+ meth +] is a symbol with the method name
+  # [+ tactuals +] are the actual arguments
+  # [+ block +] is a pair of expressions [block-args, block-body], from the block AST node
+  # [+ e +] is the expression at which location to report an error
+  def self.tc_send(scope, env, trecvs, meth, tactuals, block, e)
+    scope[:exn] = Env.join(e, scope[:exn], env) if scope.has_key? :exn # assume this call might raise an exception
+
+    # convert trecvs to array containing all receiver types
+    trecvs = trecvs.canonical
+    trecvs = if trecvs.is_a? RDL::Type::UnionType then trecvs.types else [trecvs] end
+
+    trets = []
+    trecvs.each { |trecv|
+      trets.concat(tc_send_one_recv(scope, env, trecv, meth, tactuals, block, e))
+    }
+    return RDL::Type::UnionType.new(*trets)
+  end
+
+  # Like tc_send but trecv should never be a union type
+  # Returns array of possible return types, or throws exception if there are none
+  def self.tc_send_one_recv(scope, env, trecv, meth, tactuals, block, e)
+    tmeth_inter = [] # Array<MethodType>, i.e., an intersection types
+    case trecv
+    when RDL::Type::SingletonType
+      if trecv.val.is_a? Class
+        if meth == :new then name = :initialize else name = meth end
+        ts = lookup(RDL::Util.add_singleton_marker(trecv.val.to_s), name, e)
+        ts = [RDL::Type::MethodType.new([], nil, RDL::Type::NominalType.new(trecv.val))] if (meth == :new) && (ts.nil?) # there's always a nullary new if initialize is undefined
+        error :no_singleton_method_type, [trecv.val, meth], e unless ts
+        inst = {self: trecv}
+        tmeth_inter = ts.map { |t| t.instantiate(inst) }
+      else
+        klass = trecv.val.class.to_s
+        ts = lookup(klass, meth, e)
+        error :no_instance_method_type, [klass, meth], e unless ts
+        inst = {self: trecv}
+        tmeth_inter = ts.map { |t| t.instantiate(inst) }
+      end
+    when RDL::Type::NominalType
+      ts = lookup(trecv.name, meth, e)
+      error :no_instance_method_type, [trecv.name, meth], e unless ts
+      inst = {self: trecv}
+      tmeth_inter = ts.map { |t| t.instantiate(inst) }
+    when RDL::Type::GenericType, RDL::Type::TupleType, RDL::Type::FiniteHashType
+      unless trecv.is_a? RDL::Type::GenericType
+        error :tuple_finite_hash_promote, (if trecv.is_a? RDL::Type::TupleType then ['tuple', 'Array'] else ['finite hash', 'Hash'] end), e unless trecv.promote!
+        trecv = trecv.canonical
+      end
+      ts = lookup(trecv.base.name, meth, e)
+      error :no_instance_method_type, [trecv.base.name, meth], e unless ts
+      inst = trecv.to_inst.merge(self: trecv)
+      tmeth_inter = ts.map { |t| t.instantiate(inst) }
+    else
+      raise RuntimeError, "receiver type #{t} not supported yet"
+    end
+
+    trets = [] # all possible return types
+    # there might be more than one return type because multiple cases of an intersection type might match
+    tmeth_inter.each { |tmeth| # MethodType
+      if ((tmeth.block && block) || (tmeth.block.nil? && block.nil?)) && tc_arg_types(tmeth, tactuals)
+        tc_block(scope, env, tmeth.block, block) if block
+        trets << tmeth.ret
+      end
+    }
+    if trets.empty? # no possible matching call
+      msg = <<RUBY
+Method type:
+#{ tmeth_inter.map { |ti| "        " + ti.to_s }.join("\n") }
+Actual arg type#{tactuals.size > 1 ? "s" : ""}:
+      (#{tactuals.map { |ti| ti.to_s }.join(', ')}) #{if block then '{ block }' end}
+RUBY
+      msg.chomp! # remove trailing newline
+      name = if (trecv.is_a? RDL::Type::SingletonType) && (trecv.val.is_a? Class) && (meth == :new) then
+        :initialize
+      elsif trecv.is_a? RDL::Type::SingletonType
+        trecv.val.class.to_s
+      elsif trecv.is_a? RDL::Type::NominalType
+        trecv.name
+      else
+        raise RutimeError, "impossible"
+      end
+      error :arg_type_single_receiver_error, [name, meth, msg], e
+    end
+    # TODO: issue warning if trets.size > 1 ?
+    return trets
+  end
+
+  # [+ tmeth +] is MethodType
+  # [+ actuals +] is Array<Type> containing the actual argument types
+  # return true if actuals match method type, false otherwise
+  # Very similar to MethodType#pre_cond?
+  def self.tc_arg_types(tmeth, tactuals)
+    states = [[0, 0]] # position in tmeth, position in tactuals
+    tformals = tmeth.args
+    until states.empty?
+      formal, actual = states.pop
+      if formal == tformals.size && actual == tactuals.size # Matched everything
+        return true
+      end
+      next if formal >= tformals.size # Too many actuals to match
+      t = tformals[formal]
+      if t.instance_of? RDL::Type::AnnotatedArgType
+        t = t.type
+      end
+      case t
+      when RDL::Type::OptionalType
+        t = t.type #TODO .instantiate(inst)
+        if actual == tactuals.size
+          states << [formal+1, actual] # skip over optinal formal
+        elsif (not (tactuals[actual].is_a?(RDL::Type::VarargType))) && tactuals[actual] <= t
+          states << [formal+1, actual+1] # match
+          states << [formal+1, actual] # skip
+        else
+          states << [formal+1, actual] # types don't match; must skip this formal
+        end
+      when RDL::Type::VarargType
+#        t = t.type #TODO .instantiate(inst)
+        if actual == tactuals.size
+          states << [formal+1, actual] # skip to allow empty vararg at end
+        elsif (not (tactuals[actual].is_a?(RDL::Type::VarargType))) && tactuals[actual] <= t.type
+          states << [formal, actual+1] # match, more varargs coming
+          states << [formal+1, actual+1] # match, no more varargs
+          states << [formal+1, actual] # skip over even though matches
+        elsif tactuals[actual].is_a?(RDL::Type::VarargType) && tactuals[actual] = t
+          states << [formal+1, actual+1] # match, no more varargs; no other choices!
+        else
+          states << [formal+1, actual] # doesn't match, must skip
+        end
+      else
+        if actual == tactuals.size
+          next unless t.instance_of? RDL::Type::FiniteHashType
+          if @@empty_hash_type <= t
+            states << [formal+1, actual]
+          end
+        elsif (not (tactuals[actual].is_a?(RDL::Type::VarargType))) && tactuals[actual] <= t
+          states << [formal+1, actual+1] # match!
+          # no else case; if there is no match, this is a dead end
+        end
+      end
+    end
+    false
+  end
+
+  # [+ tblock +] is the type of the block (a MethodType)
+  # [+ block +] is a pair [block-args, block-body] from the block AST node
+  # returns if the block matches type tblock
+  # otherwise throws an exception with a type error
+  def self.tc_block(scope, env, tblock, block)
+    # TODO more complex arg lists (same as self.typecheck?); also for
+    # TODO self is the same *except* instance_exec or instance_eval
+    raise RuntimeError, "block with block arg?" unless tblock.block.nil?
+    args, body = block
+    error :arg_count_mismatch, ['block', tblock.args.length, 'block', args.children.length], block[0] unless tblock.args.length == args.children.length
+    a = args.children.map { |arg| arg.children[0] }.zip(tblock.args).to_h
+
+    scope_merge(scope, outer_env: env) { |bscope|
+      # note: okay if outer_env shadows, since nested scope will include outer scope by next line
+      env = env.merge(Env.new(a))
+      _, body_type = if body.nil? then [nil, $__rdl_nil_type] else tc(bscope, env.merge(Env.new(a)), body) end
+      error :bad_return_type, [body_type, tblock.ret], body unless body.nil? || body_type <= tblock.ret
+    }
+  end
+
+  # [+ klass +] is a string containing the class name
+  # [+ name +] is a symbol naming the thing to look up (either a method or field)
+  # returns klass#name's type, walking up the inheritance hierarchy if appropriate
+  # returns nil if no type found
+  def self.lookup(klass, name, e)
+    name = $__rdl_aliases[klass][name] if $__rdl_aliases[klass] && $__rdl_aliases[klass][name]
+    t = $__rdl_info.get(klass, name, :type)
+    return t if t # simplest case, no need to walk inheritance hierarchy
+    the_klass = RDL::Util.to_class(klass)
+    included = the_klass.included_modules
+    the_klass.ancestors[1..-1].each { |ancestor|
+      # assumes ancestors is proper order to walk hierarchy
+      if (ancestor.is_a? Module) && (included.member? ancestor)
+        ancestor_name = RDL::Util.add_singleton_marker(ancestor.to_s)
+      else
+        ancestor_name = ancestor.to_s
+      end
+      tancestor = $__rdl_info.get(ancestor_name, name, :type)
+      return tancestor if tancestor
+      if (if RDL::Util.has_singleton_marker(ancestor_name) then ancestor.singleton_methods.member?(name) else ancestor.instance_methods.member?(name) end)
+        error :missing_ancestor_type, [ancestor_name, klass, name], e
+      end
+    }
+    return nil
+  end
+end
+
+# Modify Parser::MESSAGES so can use the awesome parser diagnostics printing!
+type_error_messages = {
+  bad_return_type: "got type `%s' where return type `%s' expected",
+  undefined_local_or_method: "undefined local variable or method `%s'",
+  nonmatching_range_type: "attempt to construct range with non-matching types `%s' and `%s'",
+  no_instance_method_type: "no type information for instance method `%s#%s'",
+  no_singleton_method_type: "no type information for class/singleton method `%s.%s'",
+  arg_type_single_receiver_error: "argument type error for instance method `%s#%s'\n%s",
+  untyped_var: "no type for %s variable `%s'",
+  vasgn_incompat: "incompatible types: `%s' can't be assigned to variable of type `%s'",
+  inconsistent_var_type: "local variable `%s' has declared type on some paths but not all",
+  inconsistent_var_type_type: "local variable `%s' declared with inconsistent types %s",
+  no_each_type: "can't find `each' method with signature `() { (t1) -> t2 } -> t3' in class `%s'",
+  tuple_finite_hash_promote: "can't promote %s to %s",
+  masgn_bad_rhs: "multiple assignment has right-hand side of type `%s' where tuple or array expected",
+  masgn_num: "can't multiple-assign %d values to %d variables",
+  masgn_bad_lhs: "no corresponding right-hand side elemnt for left-hand side assignee",
+  kw_not_allowed: "can't use %s in current scope",
+  kw_arg_not_allowed: "argument to %s not allowed in current scope",
+  arg_count_mismatch: "%s signature expects %d arguments, actual %s has %d arguments",
+  nonlocal_access: "variable %s from outer scope must have type declared with var_type",
+  no_block: "attempt to call yield in method not declared to take a block argument",
+  block_block: "can't call yield on a block expecting another block argument",
+  block_type_error: "argument type error for block\n%s",
+  missing_ancestor_type: "ancestor %s of %s has method %s but no type for it",
+  type_cast_format: "type_cast must be called as type_cast('type-string') or type_cast('type-string', force: expr)",
+  var_type_format: "var_type must be called as var_type(:var-name, 'type-string')",
+  generic_error: "%s",
+  exn_type: "can't determine exception type",
+  cant_splat: "can't type splat with element of type `%s'",
+  for_collection: "can't type for with collection of type `%s'",
+}
+old_messages = Parser::MESSAGES
+Parser.send(:remove_const, :MESSAGES)
+Parser.const_set :MESSAGES, (old_messages.merge(type_error_messages))