rdl 2.0.1 → 2.1.0

data/lib/rdl.rb

@@ -1,5 +1,4 @@
 # This wrapper file allows us to completely disable RDL in certain modes.
-
 if defined?(Rails)
   require 'rdl/boot_rails'
 else

data/lib/rdl/boot.rb

@@ -12,52 +12,72 @@ def RDL.config
 end
 require 'rdl/info.rb'
 
-# 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
-#   :otype to set of types that were observed at run time, where a type is a finite hash {:args => Array<Class>, :ret => Class, :block => %bool}
-#   :context_types to array of [klass, meth, Type] - method types that exist only within this method. An icky hack to deal with Rails `params`.
-# 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
-
-# Hash from class name to array of symbols that are the class's type parameters
-$__rdl_type_params = Hash.new
-
-# Hash from class name to method name to its alias method name
-# class names are strings
-# method names are symbols
-$__rdl_aliases = Hash.new
-
-# Set of [class, method] pairs to wrap.
-# class is a string
-# method is a symbol
-$__rdl_to_wrap = Set.new
-
-# Map from symbols to set of [class, method] pairs to type check when those symbols are rdl_do_typecheck'd
-# (or the methods are defined, for the symbol :now)
-$__rdl_to_typecheck = Hash.new
-$__rdl_to_typecheck[:now] = Set.new
-
-# Map from symbols to Array<Proc> where the Procs are called when those symbols are rdl_do_typecheck'd
-$__rdl_at = Hash.new
-
-# List of contracts that should be applied to the next method definition
-$__rdl_deferred = []
+module RDL::Globals
+  # 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
+  #   :otype to set of types that were observed at run time, where a type is a finite hash {:args => Array<Class>, :ret => Class, :block => %bool}
+  #   :context_types to array of [klass, meth, Type] - method types that exist only within this method. An icky hack to deal with Rails `params`.
+  # For variables
+  #   :type to type
+  @info = RDL::Info.new
+
+  # Map from full_method_name to number of times called when wrapped
+  @wrapped_calls = Hash.new 0
+
+  # Hash from class name to array of symbols that are the class's type parameters
+  @type_params = Hash.new
+
+  # Hash from class name to method name to its alias method name
+  # class names are strings
+  # method names are symbols
+  @aliases = Hash.new
+
+  # Set of [class, method] pairs to wrap.
+  # class is a string
+  # method is a symbol
+  @to_wrap = Set.new
+
+  # Map from symbols to set of [class, method] pairs to type check when those symbols are rdl_do_typecheck'd
+  # (or the methods are defined, for the symbol :now)
+  @to_typecheck = Hash.new
+  @to_typecheck[:now] = Set.new
+
+  # Map from symbols to Array<Proc> where the Procs are called when those symbols are rdl_do_typecheck'd
+  @to_do_at = Hash.new
+
+  # List of contracts that should be applied to the next method definition
+  @deferred = []
+end
+
+class << RDL::Globals # add accessors and readers for module variables
+  attr_accessor :info
+  attr_accessor :wrapped_calls
+  attr_accessor :type_params
+  attr_reader :aliases
+  attr_accessor :to_wrap
+  attr_accessor :to_typecheck
+  attr_accessor :to_do_at
+  attr_accessor :deferred
+end
 
 # Create switches to control whether wrapping happens and whether
 # contracts are checked. These need to be created before rdl/wrap.rb
 # is loaded.
 require 'rdl/switch.rb'
-$__rdl_wrap_switch = RDL::Switch.new
-$__rdl_contract_switch = RDL::Switch.new
+module RDL::Globals
+  @wrap_switch = RDL::Switch.new
+  @contract_switch = RDL::Switch.new
+end
+
+class << RDL::Globals
+  attr_reader :wrap_switch
+  attr_reader :contract_switch
+end
 
 require 'rdl/types/type.rb'
 require 'rdl/types/annotated_arg.rb'
@@ -95,39 +115,50 @@ 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
-$__rdl_proc_type = RDL::Type::NominalType.new Proc
-
-# Hash from special type names to their values
-$__rdl_special_types = {'%any' => $__rdl_top_type,
-                        '%bot' => $__rdl_bot_type,
-                        '%bool' => $__rdl_bool_type}
+module RDL::Globals
+  FIXBIG_VERSIONS = ['>= 2.0.0', '< 2.4.0']
+  # INTEGER_VERSIONS = '>= 2.4.0'
+
+  @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
+  @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
+  @types = Hash.new
+  @types[:nil] = RDL::Type::NominalType.new NilClass # actually creates singleton type
+  @types[:top] = RDL::Type::TopType.new
+  @types[:bot] = RDL::Type::BotType.new
+  @types[:object] = RDL::Type::NominalType.new Object
+  @types[:true] = RDL::Type::NominalType.new TrueClass # actually creates singleton type
+  @types[:false] = RDL::Type::NominalType.new FalseClass # also singleton type
+  @types[:bool] = RDL::Type::UnionType.new(@types[:true], @types[:false])
+  @types[:float] = RDL::Type::NominalType.new Float
+  @types[:complex] = RDL::Type::NominalType.new Complex
+  @types[:rational] = RDL::Type::NominalType.new Rational
+  @types[:integer] = RDL::Type::NominalType.new Integer
+  @types[:numeric] = RDL::Type::NominalType.new Numeric
+  @types[:string] = RDL::Type::NominalType.new String
+  @types[:array] = RDL::Type::NominalType.new Array
+  @types[:hash] = RDL::Type::NominalType.new Hash
+  @types[:symbol] = RDL::Type::NominalType.new Symbol
+  @types[:range] = RDL::Type::NominalType.new Range
+  @types[:regexp] = RDL::Type::NominalType.new Regexp
+  @types[:standard_error] = RDL::Type::NominalType.new StandardError
+  @types[:proc] = RDL::Type::NominalType.new Proc
+
+  # Hash from special type names to their values
+  @special_types = {'%any' => @types[:top],
+                    '%bot' => @types[:bot],
+                    '%bool' => @types[:bool]}
+end
+
+class << RDL::Globals
+  attr_reader :parser
+  attr_accessor :parser_cache
+  attr_reader :types
+  attr_reader :special_types
+end

data/lib/rdl/boot_rails.rb

@@ -2,14 +2,8 @@ if Rails.env.development? || Rails.env.test?
   require 'rdl/boot'
   require 'types/core'
 
-  version = Rails::VERSION::STRING.split('.')[0] + ".x"
-
-  begin
-    require_relative "../types/rails-#{version}/_helpers.rb" # load type aliases first
-    Dir[File.dirname(__FILE__) + "/../types/rails-#{version}/**/*.rb"].each { |f| require f }
-  rescue LoadError
-    $stderr.puts("rdl could not load type definitions for Rails v#{version}")
-  end
+  require_relative "../types/rails/_helpers.rb" # load type aliases first
+  Dir[File.dirname(__FILE__) + "/../types/rails/**/*.rb"].each { |f| require f }
 elsif Rails.env.production?
   require 'rdl_disable'
   class ActionController::Base

data/lib/rdl/config.rb

@@ -5,26 +5,47 @@ class RDL::Config
 
   attr_accessor :nowrap
   attr_accessor :gather_stats
-  attr_accessor :report
-  attr_accessor :guess_types
+  attr_reader :report # writer is custom defined
   attr_accessor :type_defaults, :pre_defaults, :post_defaults
 
   def initialize
-    @nowrap = Set.new
+    @nowrap = Set.new # Set of symbols
     @gather_stats = false
-    @report = false
-    @guess_types = []
+    @report = false # if this is enabled by default, modify @at_exit_installed
+    @guess_types = [] # same as above
+    @at_exit_installed = false
     @type_defaults = { wrap: true, typecheck: false }
     @pre_defaults = { wrap: true }
     @post_defaults = { wrap: true }
   end
 
+  def report=(val)
+    install_at_exit
+    @report = val
+  end
+
+  def guess_types
+    install_at_exit
+    return @guess_types
+  end
+
+  def guess_types=(val)
+    install_at_exit
+    @guess_types = val
+  end
+
   def add_nowrap(*klasses)
-    klasses.each { |klass| @nowrap.add klass }
+    klasses.each { |klass|
+      @nowrap.add klass.to_s.to_sym
+      @nowrap.add RDL::Util.add_singleton_marker(klass.to_s).to_sym
+    }
   end
 
   def remove_nowrap(*klasses)
-    klasses.each { |klass| @nowrap.delete klass }
+    klasses.each { |klass|
+      @nowrap.delete klass.to_s.to_sym
+      @nowrap.delete RDL::Util.add_singleton_marker(klass.to_s).to_sym
+    }
   end
 
   # To use, copy these 3 lines to the test file of a gem
@@ -39,7 +60,7 @@ RDL::Config.instance.profile_stats
 
     at_exit do
       Profiler__.stop_profile
-      $__rdl_contract_switch.off {
+      RDL::Globals.contract_switch.off {
         puts "START."
         puts "Performing Profile Analysis"
         # Class Name => [Times Contract Called | Times Called | Time | Time | Class Profile]
@@ -75,7 +96,7 @@ RDL::Config.instance.profile_stats
         }
 
         p "Scanning RDL Contract Log"
-        $__rdl_wrapped_calls.each{ |mname,ct|
+        RDL::Globals.wrapped_calls.each{ |mname,ct|
           if (totals[mname]) then
             if (totals[mname][0]) then
               totals[mname][0] = ct
@@ -132,7 +153,7 @@ RDL::Config.instance.profile_stats
     puts "------------------------------"
     typechecked = []
     missing = []
-    $__rdl_info.info.each_pair { |klass, meths|
+    RDL::Globals.info.info.each_pair { |klass, meths|
       meths.each { |meth, kinds|
         if kinds[:typecheck]
           if kinds[:typechecked]
@@ -186,16 +207,16 @@ RDL::Config.instance.profile_stats
     puts " -> XXXX'"
 
     # next print based on observed types
-    otypes = $__rdl_info.get(klass, meth, :otype) if $__rdl_info.has?(klass, meth, :otype) # observed types
+    otypes = RDL::Globals.info.get(klass, meth, :otype) if RDL::Globals.info.has?(klass, meth, :otype) # observed types
     return if otypes.nil?
     first = true
     print "  type #{if is_sing then '\'self.' + meth + '\'' else ':' + meth end}, '("
     otargs = []
-    otret = $__rdl_bot_type
+    otret = RDL::Globals.types[:bot]
     otblock = false
     otypes.each { |ot|
       ot[:args].each_with_index { |t, i|
-        otargs[i] = $__rdl_bot_type if otargs[i].nil?
+        otargs[i] = RDL::Globals.types[:bot] if otargs[i].nil?
         otargs[i] = RDL::Type::UnionType.new(otargs[i], RDL::Type::NominalType.new(t)).canonical
       }
       otret = RDL::Type::UnionType.new(otret, RDL::Type::NominalType.new(ot[:ret])).canonical
@@ -233,7 +254,13 @@ RDL::Config.instance.profile_stats
   end
 end
 
-at_exit do
-  RDL::Config.instance.do_report
-  RDL::Config.instance.do_guess_types
-end
+private
+
+  def install_at_exit
+    return if @at_exit_installed
+    at_exit do
+      RDL::Config.instance.do_report
+      RDL::Config.instance.do_guess_types
+    end
+    @at_exit_installed = true
+  end

data/lib/rdl/contracts/flat.rb

@@ -8,7 +8,7 @@ module RDL::Contract
     end
 
     def check(slf, *v, &blk)
-      $__rdl_contract_switch.off {
+      RDL::Globals.contract_switch.off {
         if @pred && v.length >= @pred.arity
           unless blk ? slf.instance_exec(*v, blk, &@pred) : slf.instance_exec(*v, &@pred) # TODO: Fix blk
 #          unless blk ? pred.call(*v, &blk) : pred.call(*v)

data/lib/rdl/info.rb

@@ -23,7 +23,7 @@ class RDL::Info
   # 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
+    klass = RDL::Util.to_class_str(klass)
     label = label.to_sym
     @info[klass] = {} unless @info[klass]
     @info[klass][label] = {} unless @info[klass][label]
@@ -73,8 +73,8 @@ class RDL::Info
   end
 
   def get_with_aliases(klass, label, kind)
-    while $__rdl_aliases[klass] && $__rdl_aliases[klass][label]
-      label = $__rdl_aliases[klass][label]
+    while RDL::Globals.aliases[klass] && RDL::Globals.aliases[klass][label]
+      label = RDL::Globals.aliases[klass][label]
     end
     get(klass, label, kind)
   end

data/lib/rdl/query.rb

@@ -17,25 +17,25 @@ class RDL::Query
 #      klass = self.class.to_s
 #      meth = q.to_sym
     end
-    return $__rdl_info.get(klass, meth, :type)
+    return RDL::Globals.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_info.info.has_key? klass
+    return nil unless RDL::Globals.info.info.has_key? klass
     cls_meths = []
     cls_klass = RDL::Util.add_singleton_marker(klass)
-    if $__rdl_info.info.has_key? cls_klass then
-      $__rdl_info.info[cls_klass].each { |meth, kinds|
+    if RDL::Globals.info.info.has_key? cls_klass then
+      RDL::Globals.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_info.info.has_key? klass then
-      $__rdl_info.info[klass].each { |meth, kinds|
+    if RDL::Globals.info.info.has_key? klass then
+      RDL::Globals.info.info[klass].each { |meth, kinds|
         if kinds.has_key? :type then
           kinds[:type].each { |t| inst_meths << [meth.to_s, t] }
         end
@@ -49,9 +49,9 @@ class RDL::Query
 
   # Returns sorted list of pairs [method name, type] matching query. The query should be a string containing a method type query.
   def self.method_type_query(q)
-    q = $__rdl_parser.scan_str "#Q #{q}"
+    q = RDL::Globals.parser.scan_str "#Q #{q}"
     result = []
-    $__rdl_info.info.each { |klass, meths|
+    RDL::Globals.info.info.each { |klass, meths|
       meths.each { |meth, kinds|
         if kinds.has_key? :type then
           kinds[:type].each { |t|
@@ -67,10 +67,10 @@ class RDL::Query
   end
 end
 
-class Object
+module RDL
 
-  def rdl_query(q)
-    $__rdl_contract_switch.off {
+  def self.query(q)
+    RDL::Globals.contract_switch.off {
       if q =~ /^[A-Z]\w*(#|\.)([a-z_]\w*(!|\?|=)?|!|~|\+|\*\*|-|\*|\/|%|<<|>>|&|\||\^|<|<=|=>|>|==|===|!=|=~|!~|<=>|\[\]|\[\]=)$/
         typs = RDL::Query.method_query(q)
         if typs.nil? then

data/lib/rdl/typecheck.rb

@@ -124,7 +124,7 @@ module RDL::Typecheck
           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 = RDL::Type::UnionType.new(first_typ, *rest.map { |other| ((other.has_key? var) && other[var]) || RDL::Globals.types[:nil] })
           typ = typ.canonical
           env.env[var] = {type: typ, fixed: false}
         end
@@ -155,15 +155,30 @@ module RDL::Typecheck
 
   # 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"))
+    raise StaticTypeError, ("\n" + (Diagnostic.new :error, reason, args, ast.loc.expression).render.join("\n"))
   end
 
   def self.note(reason, args, ast)
-    puts (Parser::Diagnostic.new :note, reason, args, ast.loc.expression).render
+    puts (Diagnostic.new :note, reason, args, ast.loc.expression).render
+  end
+
+  def self.get_leaves(node, r=[])
+    node.children.each {|n|
+      if n.is_a? AST::Node
+        get_leaves(n, r)
+      elsif n
+        r.push n
+      end
+    }
+    r
+  end
+
+  def self.is_RDL(node)
+    return node != nil && node.type == :const && node.children[0] == nil && node.children[1] == :RDL
   end
 
   def self.get_ast(klass, meth)
-    file, line = $__rdl_info.get(klass, meth, :source_location)
+    file, line = RDL::Globals.info.get(klass, meth, :source_location)
     raise RuntimeError, "No file for #{RDL::Util.pp_klass_method(klass, meth)}" if file.nil?
     raise RuntimeError, "static type checking in irb not supported" if file == "(irb)"
     if file == "(pry)"
@@ -179,23 +194,24 @@ module RDL::Typecheck
     end
 
     digest = Digest::MD5.file file
-    cache_hit = (($__rdl_ruby_parser_cache.has_key? file) &&
-                 ($__rdl_ruby_parser_cache[file][0] == digest))
+    cache_hit = ((RDL::Globals.parser_cache.has_key? file) &&
+                 (RDL::Globals.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]
+      RDL::Globals.parser_cache[file] = [digest, cache]
     end
-    ast = $__rdl_ruby_parser_cache[file][1][:line_defs][line]
+    ast = RDL::Globals.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?
     return ast
   end
 
   def self.typecheck(klass, meth)
+    @cur_meth = [klass, meth]
     ast = get_ast(klass, meth)
-    types = $__rdl_info.get(klass, meth, :type)
+    types = RDL::Globals.info.get(klass, meth, :type)
     raise RuntimeError, "Can't typecheck method with no types?!" if types.nil? or types == []
 
     if ast.type == :def
@@ -206,7 +222,7 @@ module RDL::Typecheck
       raise RuntimeError, "Unexpected ast type #{ast.type}"
     end
     raise RuntimeError, "Method #{name} defined where method #{meth} expected" if name.to_sym != meth
-    context_types = $__rdl_info.get(klass, meth, :context_types)
+    context_types = RDL::Globals.info.get(klass, meth, :context_types)
     types.each { |type|
       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
@@ -214,6 +230,10 @@ module RDL::Typecheck
       else
         self_type = RDL::Type::NominalType.new(klass)
       end
+      if meth == :initialize
+        # initialize method must always return "self" or GenericType where base is "self"
+        error :bad_initialize_type, [], ast unless ((type.ret.is_a?(RDL::Type::VarType) && type.ret.name == :self) || (type.ret.is_a?(RDL::Type::GenericType) && type.ret.base.is_a?(RDL::Type::VarType) && type.ret.base.name == :self))
+      end
       inst = {self: self_type}
       type = type.instantiate inst
       _, targs = args_hash({}, Env.new, type, args, ast, 'method')
@@ -222,14 +242,14 @@ module RDL::Typecheck
       begin
         old_captured = scope[:captured].dup
         if body.nil?
-          body_type = $__rdl_nil_type
+          body_type = RDL::Globals.types[:nil]
         else
           _, body_type = tc(scope, Env.new(targs.merge(scope[:captured])), body)
         end
       end until old_captured == scope[:captured]
-      error :bad_return_type, [body_type.to_s, type.ret.to_s], body unless body.nil? || body_type <= type.ret
+      error :bad_return_type, [body_type.to_s, type.ret.to_s], body unless body.nil? || meth == :initialize || body_type <= type.ret
     }
-    $__rdl_info.set(klass, meth, :typechecked, true)
+    RDL::Globals.info.set(klass, meth, :typechecked, true)
   end
 
   # [+ scope +] is used to typecheck default values for optional arguments
@@ -262,7 +282,7 @@ module RDL::Typecheck
       elsif arg.type == :restarg
         error :type_arg_kind_mismatch, [kind, 'optional', 'vararg'], arg if targ.optional?
         error :type_arg_kind_mismatch, [kind, 'required', 'vararg'], arg if !targ.vararg?
-        targs[arg.children[0]] = RDL::Type::GenericType.new($__rdl_array_type, targ.type)
+        targs[arg.children[0]] = RDL::Type::GenericType.new(RDL::Globals.types[:array], targ.type)
         tpos += 1
       elsif arg.type == :kwarg
         error :type_args_no_kws, [kind], arg unless targ.is_a?(RDL::Type::FiniteHashType)
@@ -285,7 +305,7 @@ module RDL::Typecheck
       elsif arg.type == :kwrestarg
         error :type_args_no_kws, [kind], e unless targ.is_a?(RDL::Type::FiniteHashType)
         error :type_args_no_kw_rest, [kind], arg if targ.rest.nil?
-        targs[arg.children[0]] = RDL::Type::GenericType.new($__rdl_hash_type, $__rdl_symbol_type, targ.rest)
+        targs[arg.children[0]] = RDL::Type::GenericType.new(RDL::Globals.types[:hash], RDL::Globals.types[:symbol], targ.rest)
         kw_rest_matched = true
       elsif arg.type == :blockarg
         error :type_arg_block, [kind, kind], arg unless type.block
@@ -305,6 +325,27 @@ module RDL::Typecheck
     return [env, targs]
   end
 
+  def self.get_super_owner(slf, m)
+    case slf
+    when RDL::Type::SingletonType
+      if slf.nominal.name == 'Class'
+        trecv_owner = get_super_owner_from_class(slf.val.singleton_class, m)
+        RDL::Type::SingletonType.new(RDL::Util.singleton_class_to_class(trecv_owner))
+      else
+        raise Exception, 'self is singleton class but nominal is not Class'
+      end
+    when RDL::Type::NominalType
+      RDL::Type::NominalType.new(get_super_owner_from_class(slf.klass, m))
+    else
+      raise Exception, 'unsupported self #{slf} in get_super_owner'
+    end
+  end
+
+  def self.get_super_owner_from_class(cls, m)
+    raise Exception, "cls #{cls} is not a Class" if cls.class != Class
+    cls.superclass.instance_method(m).owner
+  end
+
   # The actual type checking logic.
   # [+ scope +] tracks flow-insensitive information about the current scope, excluding local variables
   # [+ env +] is the (local variable) Env
@@ -314,11 +355,11 @@ module RDL::Typecheck
   def self.tc(scope, env, e)
     case e.type
     when :nil
-      [env, $__rdl_nil_type]
+      [env, RDL::Globals.types[:nil]]
     when :true
-      [env, $__rdl_true_type]
+      [env, RDL::Globals.types[:true]]
     when :false
-      [env, $__rdl_false_type]
+      [env, RDL::Globals.types[:false]]
     when :complex, :rational, :str, :string # constants
       [env, RDL::Type::NominalType.new(e.children[0].class)]
     when :int, :float, :sym # singletons
@@ -326,15 +367,15 @@ module RDL::Typecheck
     when :dstr, :xstr # string (or execute-string) with interpolation
       envi = env
       e.children.each { |ei| envi, _ = tc(scope, envi, ei) }
-      [envi, $__rdl_string_type]
+      [envi, RDL::Globals.types[:string]]
     when :dsym # symbol with interpolation
       envi = env
       e.children.each { |ei| envi, _ = tc(scope, envi, ei) }
-      [envi, $__rdl_symbol_type]
+      [envi, RDL::Globals.types[:symbol]]
     when :regexp
       envi = env
       e.children.each { |ei| envi, _ = tc(scope, envi, ei) unless ei.type == :regopt }
-      [envi, $__rdl_regexp_type]
+      [envi, RDL::Globals.types[:regexp]]
     when :array
       envi = env
       tis = []
@@ -350,16 +391,16 @@ module RDL::Typecheck
             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
+          elsif ti.is_a?(RDL::Type::GenericType) && ti.base == RDL::Globals.types[:array]
             is_array = true
             tis << ti.params[0]
-          elsif ti.is_a?(RDL::Type::GenericType) && ti.base == $__rdl_hash_type
+          elsif ti.is_a?(RDL::Type::GenericType) && ti.base == RDL::Globals.types[:hash]
             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)
+          elsif (RDL::Globals.types[:array] <= ti) || (ti <= RDL::Globals.types[:array]) ||
+                (RDL::Globals.types[:hash] <= ti) || (ti <= RDL::Globals.types[:hash])
             # might or might not be array...can't splat...
             error :cant_splat, [ti], ei
           else
@@ -371,7 +412,7 @@ module RDL::Typecheck
         end
       }
       if is_array
-        [envi, RDL::Type::GenericType.new($__rdl_array_type, RDL::Type::UnionType.new(*tis).canonical)]
+        [envi, RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::UnionType.new(*tis).canonical)]
       else
         [envi, RDL::Type::TupleType.new(*tis)]
       end
@@ -394,7 +435,7 @@ module RDL::Typecheck
             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
+          elsif tkwsplat.is_a?(RDL::Type::GenericType) && tkwsplat.base == RDL::Globals.types[:hash]
             is_fh = false
             tlefts << tkwsplat.params[0]
             trights << tkwsplat.params[1]
@@ -412,7 +453,7 @@ module RDL::Typecheck
       else
         tleft = RDL::Type::UnionType.new(*tlefts)
         tright = RDL::Type::UnionType.new(*trights)
-        [envi, RDL::Type::GenericType.new($__rdl_hash_type, tleft, tright)]
+        [envi, RDL::Type::GenericType.new(RDL::Globals.types[:hash], tleft, tright)]
       end
       #TODO test!
 #    when :kwsplat # TODO!
@@ -423,7 +464,7 @@ module RDL::Typecheck
       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 unless t1 <= t2 || t2 <= t1
-      [env2, RDL::Type::GenericType.new($__rdl_range_type, t1)]
+      [env2, RDL::Type::GenericType.new(RDL::Globals.types[:range], t1)]
     when :self
       [env, env[:self]]
     when :lvar, :ivar, :cvar, :gvar
@@ -431,7 +472,7 @@ module RDL::Typecheck
     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)))
+      env = env.bind(x, RDL::Globals.types[:nil]) 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
@@ -439,7 +480,7 @@ module RDL::Typecheck
       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
+        env = env.bind(x, RDL::Globals.types[:nil]) 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])
@@ -471,7 +512,7 @@ module RDL::Typecheck
           }
           [envi, tright]
         end
-      elsif (tright.is_a? RDL::Type::GenericType) && (tright.base == $__rdl_array_type)
+      elsif (tright.is_a? RDL::Type::GenericType) && (tright.base == RDL::Globals.types[:array])
         tasgn = tright.params[0]
         lhs.each { |asgn|
           if asgn.type == :splat
@@ -489,16 +530,27 @@ module RDL::Typecheck
         # (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()
+        elargs = e.children[0].children[2]
+
+        if elargs
+          envleft, elargs = tc(scope, envleft, elargs)
+          largs = [elargs]
+        else
+          largs = []
+        end
+
+        tloperand = tc_send(scope, envleft, trecv, meth, largs, 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)
+
+        tright = largs.push(tright) if largs
         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))
+        tres = tc_send(scope, envoperand, trecv, mutation_meth, tright, nil, e) # call recv.meth=(recvt.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
+        env = env.bind(x, RDL::Globals.types[:nil]) 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)
@@ -513,7 +565,7 @@ module RDL::Typecheck
         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
+        env = env.bind(x, RDL::Globals.types[:nil]) 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
@@ -534,20 +586,51 @@ module RDL::Typecheck
         tc_vasgn(scope, envi, e.children[0].type, x, trhs, e)
       end
     when :nth_ref, :back_ref
-      [env, $__rdl_string_type]
+      [env, RDL::Globals.types[:string]]
     when :const
       c = nil
       if e.children[0].nil?
-        c = env[:self].klass.const_get(e.children[1])
+        case env[:self]
+        when RDL::Type::SingletonType
+          sclass = env[:self].val
+        when RDL::Type::NominalType
+          sclass = env[:self].klass
+        else
+          raise Exception, "unsupported env[self]=#{env[:self]}"
+        end
+        c1_str = RDL::Util.to_class_str(e.children[1])
+        self_klass_str = RDL::Util.to_class_str(sclass)
+        if self_klass_str.end_with?('::' + c1_str)
+          i = self_klass_str.rindex('::' + c1_str)
+          pc = RDL::Util.to_class self_klass_str[0..i-1]
+          c = pc.const_get(e.children[1])
+        else
+          if self_klass_str['::']
+            i = self_klass_str.rindex('::')
+            sclass = RDL::Util.to_class self_klass_str[0..i-1]
+          end
+          c = sclass.const_get(e.children[1])
+        end
       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!
+      elsif e.children[0].type == :const
+        if env[:self]
+          if env[:self].is_a?(RDL::Type::SingletonType)
+            ic = env[:self].val
+          else
+            ic = env[:self].class
+          end
+        else
+          ic = Object
+        end
+        c = get_leaves(e).inject(ic) {|m, c2| m.const_get(c2)}
       else
         raise "const other not implemented yet"
       end
       case c
-      when TrueClass, FalseClass, Complex, Rational, Fixnum, Bignum, Float, Symbol, Class
+      when TrueClass, FalseClass, Complex, Rational, Integer, Float, Symbol, Class
         [env, RDL::Type::SingletonType.new(c)]
       when Module
         t = RDL::Type::SingletonType.new(const_get(e.children[1]))
@@ -557,24 +640,25 @@ module RDL::Typecheck
       end
     when :defined?
       # do not type check subexpression, since it may not be type correct, e.g., undefined variable
-      [env, $__rdl_string_type]
+      [env, RDL::Globals.types[:string]]
     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?
-      return tc_type_cast(scope, env, e) if e.children[1] == :type_cast && scope[:block].nil?
-      return tc_note_type(scope, env, e) if e.children[1] == :rdl_note_type && e.children[0].nil?
+      return tc_var_type(scope, env, e) if (e.children[0].nil? || is_RDL(e.children[0])) && e.children[1] == :var_type
+      return tc_type_cast(scope, env, e) if is_RDL(e.children[0]) && e.children[1] == :type_cast && scope[:block].nil?
+      return tc_note_type(scope, env, e) if is_RDL(e.children[0]) && e.children[1] == :rdl_note_type
+      return tc_instantiate!(scope, env, e) if is_RDL(e.children[0]) && e.children[1] == :instantiate!
       envi = env
       tactuals = []
       block = scope[:block]
-      scope_merge(scope, block: nil) { |sscope|
+      scope_merge(scope, block: nil, break: env, next: env) { |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
+            elsif ti.is_a?(RDL::Type::GenericType) && ti.base == RDL::Globals.types[:array]
               tactuals << RDL::Type::VarargType.new(ti.params[0]) # Turn Array<t> into *t
             else
               error :cant_splat, [ti], ei.children[0]
@@ -631,15 +715,15 @@ RUBY
     # 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
+    #     if t1.val then [a1, RDL::Globals.types[:false]] else [a1, RDL::Globals.types[:true]] end
     #   else
-    #     [a1, $__rdl_bool_type]
+    #     [a1, RDL::Globals.types[:bool]]
     #   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
+      envleft, tleft = if e.children[1].nil? then [envi, RDL::Globals.types[:nil]] else tc(scope, envi, e.children[1]) end # then
+      envright, tright = if e.children[2].nil? then [envi, RDL::Globals.types[:nil]] 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
@@ -685,7 +769,13 @@ RUBY
             # previous, unrefined type
           end
         end
-        envbody, tbody = tc(scope, initial_env, wclause.children[-1]) # last wclause child is body
+        if wclause.children[-1] == nil
+          envbody = initial_env
+          tbody = RDL::Globals.types[:nil]
+        else
+          envbody, tbody = tc(scope, initial_env, wclause.children[-1]) # last wclause child is body
+        end
+
         tbodies << tbody
         envbodies << envbody
       }
@@ -705,7 +795,7 @@ RUBY
       # 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|
+      scope_merge(scope, break: env_break, tbreak: RDL::Globals.types[:nil], next: env, redo: env_break) { |lscope|
         begin
           old_break = lscope[:break]
           old_next = lscope[:next]
@@ -724,7 +814,7 @@ RUBY
       # 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|
+      scope_merge(scope, break: nil, tbreak: RDL::Globals.types[:nil], 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)
@@ -807,12 +897,16 @@ RUBY
         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]
+      [env, RDL::Globals.types[:bot]]
     when :return
       # TODO return in lambda returns from lambda and not outer scope
-      env1, t1 = tc(scope, env, e.children[0])
+      if e.children[0]
+         env1, t1 = tc(scope, env, e.children[0])
+      else
+         env1, t1 = [env, RDL::Globals.types[:nil]]
+      end
       error :bad_return_type, [t1.to_s, scope[:tret]], e unless t1 <= scope[:tret]
-      [env1, $__rdl_bot_type] # return is a void value expression
+      [env1, RDL::Globals.types[:bot]] # return is a void value expression
     when :begin, :kwbegin # sequencing
       envi = env
       ti = nil
@@ -864,12 +958,68 @@ RUBY
           texns << RDL::Type::NominalType.new(texn.val)
         }
       else
-        texns = [$__rdl_standard_error_type]
+        texns = [RDL::Globals.types[:standard_error]]
       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])
+    when :super
+      envi = env
+      tactuals = []
+      block = scope[:block]
+
+      if block
+        raise Exception, 'block in super method with block not supported'
+      end
+
+      scope_merge(scope, block: nil, break: env, next: env) { |sscope|
+        e.children.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.params[0]) # Turn Array<t> into *t
+            else
+              error :cant_splat, [ti], ei.children[0]
+            end
+          elsif ei.type == :block_pass
+            raise RuntimeError, "impossible to pass block arg and literal block" if scope[:block]
+            envi, ti = tc(sscope, envi, ei.children[0])
+            # convert using to_proc if necessary
+            ti = tc_send(sscope, envi, ti, :to_proc, [], nil, ei) unless ti.is_a? RDL::Type::MethodType
+            block = [ti, ei]
+          else
+            envi, ti = tc(sscope, envi, ei)
+            tactuals << ti
+          end
+        }
+
+        trecv = get_super_owner(envi[:self], @cur_meth[1])
+        [envi, tc_send(sscope, envi, trecv, @cur_meth[1], tactuals, block, e).canonical]
+      }
+    when :zsuper
+      envi = env
+      block = scope[:block]
+
+      if block
+        raise Exception, 'super method not supported'
+      end
+
+      klass = RDL::Util.to_class @cur_meth[0]
+      mname = @cur_meth[1]
+      sklass = get_super_owner_from_class klass, mname
+      sklass_str = RDL::Util.to_class_str sklass
+      stype = RDL::Globals.info.get_with_aliases(sklass_str, mname, :type)
+      error :no_instance_method_type, [sklass_str, mname], e unless stype
+      raise Exception, "unsupported intersection type in super, e = #{e}" if stype.size > 1
+      tactuals = stype[0].args
+
+      scope_merge(scope, block: nil, break: env, next: env) { |sscope|
+        trecv = get_super_owner(envi[:self], @cur_meth[1])
+        [envi, tc_send(sscope, envi, trecv, @cur_meth[1], tactuals, block, e).canonical]
+      }
     else
       raise RuntimeError, "Expression kind #{e.type} unsupported"
     end
@@ -890,13 +1040,13 @@ RUBY
       end
     when :ivar, :cvar, :gvar
       klass = (if kind == :gvar then RDL::Util::GLOBAL_NAME else env[:self] end)
-      unless $__rdl_info.has?(klass, name, :type)
+      unless RDL::Globals.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
+        error :untyped_var, [kind_text, name, klass], e
       end
-      [env, $__rdl_info.get(klass, name, :type).canonical]
+      [env, RDL::Globals.info.get(klass, name, :type).canonical]
     else
       raise RuntimeError, "unknown kind #{kind}"
     end
@@ -919,13 +1069,13 @@ RUBY
       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)
+      unless RDL::Globals.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
+        error :untyped_var, [kind_text, name, klass], e
       end
-      tleft = $__rdl_info.get(klass, name, :type)
+      tleft = RDL::Globals.info.get(klass, name, :type)
       error :vasgn_incompat, [tright.to_s, tleft.to_s], e unless tright <= tleft
       [env, tright.canonical]
     when :send
@@ -955,24 +1105,24 @@ RUBY
     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)
+      typ = RDL::Globals.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]
+    [env.fix(var, typ), RDL::Globals.types[:nil]]
   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?
+    error :type_cast_format, [], e unless e.children.length <= 5
+    typ_str = e.children[3].children[0] if (e.children[3].type == :str) || (e.children[3].type == :string)
+    error :type_cast_format, [], e.children[3] if typ_str.nil?
     begin
-      typ = $__rdl_parser.scan_str("#T " + typ_str)
+      typ = RDL::Globals.parser.scan_str("#T " + typ_str)
     rescue Racc::ParseError => err
-      error :generic_error, [err.to_s[1..-1]], e.children[2] # remove initial newline
+      error :generic_error, [err.to_s[1..-1]], e.children[3] # remove initial newline
     end
-    if e.children[3]
-      fh = e.children[3]
+    if e.children[4]
+      fh = e.children[4]
       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
@@ -983,12 +1133,66 @@ RUBY
   end
 
   def self.tc_note_type(scope, env, e)
-    error :note_type_format, [], e unless e.children.length == 3 && scope[:block].nil?
-    env, typ = tc(scope, env, e.children[2])
-    note :note_type, [typ], e.children[2]
+    error :note_type_format, [], e unless e.children.length == 4 && scope[:block].nil?
+    env, typ = tc(scope, env, e.children[3])
+    note :note_type, [typ], e.children[3]
     [env, typ]
   end
 
+  def self.tc_instantiate!(scope, env, e)
+    error :instantiate_format, [], e if e.children.length < 4
+    env, obj_typ = tc(scope, env, e.children[2])
+    case obj_typ
+    when RDL::Type::GenericType
+      klass = obj_typ.base.name.to_s
+    when RDL::Type::NominalType
+      klass = obj_typ.name.to_s
+    when RDL::Type::TupleType
+      klass = "Array"
+    when RDL::Type::FiniteHashType
+      klass = "Hash"
+    when RDL::Type::SingletonType
+      klass = if obj_typ.val.is_a?(Class) then obj_typ.val.to_s else obj_typ.val.class.to_s end
+    else
+      error :bad_inst_type, [obj_typ], e
+    end
+
+    formals, _, _ = RDL::Globals.type_params[klass]
+
+    if e.children.last.type == :hash
+      typ_args = e.children[3..-2]
+    else
+      typ_args = e.children[3..-1]
+    end
+    error :inst_not_param, [klass], e unless formals
+    error :inst_num_args, [formals.size, typ_args.size], e unless formals.size == typ_args.size
+
+    new_typs = []
+    typ_args.each { |a|
+      env, arg_typ = tc(scope, env, a)
+      case arg_typ
+      when RDL::Type::SingletonType
+        error :instantiate_format, [], a unless arg_typ.val.is_a?(Class)
+        new_typs << RDL::Globals.parser.scan_str("#T #{arg_typ.val}")
+      else
+        error :instantiate_format, [], a unless (a.type == :str) || (a.type == :string) || (a.type == :sym)
+        new_typs << RDL::Globals.parser.scan_str("#T #{a.children[0]}")
+      end
+    }
+
+    t = RDL::Type::GenericType.new(RDL::Type::NominalType.new(klass), *new_typs)
+    case e.children[2].type
+    when :lvar
+      var_name = e.children[2].children[0]
+    else
+      raise RuntimeError, "instantiate! expects local variable as receiver"
+      error :inst_lvar, [], e
+    end
+
+    env = env.bind(var_name, t)
+    [env, t]
+  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.
@@ -1016,14 +1220,24 @@ RUBY
   # 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)
+    return tc_send_class(trecv, e) if (meth == :class) && (tactuals.empty?)
     tmeth_inter = [] # Array<MethodType>, i.e., an intersection types
     case trecv
     when RDL::Type::SingletonType
       if trecv.val.is_a? Class or trecv.val.is_a? Module
-        ts = lookup(scope, RDL::Util.add_singleton_marker(trecv.val.to_s), meth, e)
+        if meth == :new then
+          meth_lookup = :initialize
+          trecv_lookup = trecv.val.to_s
+          self_inst = RDL::Type::NominalType.new(trecv.val)
+        else
+          meth_lookup = meth
+          trecv_lookup = RDL::Util.add_singleton_marker(trecv.val.to_s)
+          self_inst = trecv
+        end
+        ts = lookup(scope, trecv_lookup, meth_lookup, 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}
+        inst = {self: self_inst}
         tmeth_inter = ts.map { |t| t.instantiate(inst) }
       elsif trecv.val.is_a?(Symbol) && meth == :to_proc
         # Symbol#to_proc on a singleton symbol type produces a Proc for the method of the same name
@@ -1064,10 +1278,10 @@ RUBY
         tmeth_inter = [trecv]
       else
         # treat as Proc
-        tc_send_one_recv(scope, env, $__rdl_proc_type, meth, tactuals, block, e)
+        tc_send_one_recv(scope, env, RDL::Globals.types[:proc], meth, tactuals, block, e)
       end
     else
-      raise RuntimeError, "receiver type #{trecv} not supported yet"
+      raise RuntimeError, "receiver type #{trecv} not supported yet, meth=#{meth}"
     end
 
     trets = [] # all possible return types
@@ -1082,7 +1296,19 @@ RUBY
           tmeth_inst = tc_arg_types(tmeth, tactuals_expanded)
           if tmeth_inst
             tc_block(scope, env, tmeth.block, block, tmeth_inst) if block
-            trets_tmp << tmeth.ret.instantiate(tmeth_inst) # found a match for this subunion; add its return type to trets_tmp
+            if trecv.is_a?(RDL::Type::SingletonType) && meth == :new
+              init_typ = RDL::Type::NominalType.new(trecv.val)
+              if (tmeth.ret.instance_of?(RDL::Type::GenericType))
+                error :bad_initialize_type, [], e unless (tmeth.ret.base == init_typ)
+              elsif (tmeth.ret.instance_of?(RDL::Type::AnnotatedArgType) || tmeth.ret.instance_of?(RDL::Type::DependentArgType))
+                error :bad_initialize_type, [], e unless (tmeth.ret.type == init_typ)
+              else
+                error :bad_initialize_type, [], e unless (tmeth.ret == init_typ)
+              end
+              trets_tmp << init_typ
+            else
+              trets_tmp << tmeth.ret.instantiate(tmeth_inst) # found a match for this subunion; add its return type to trets_tmp
+            end
           end
         end
       }
@@ -1119,6 +1345,33 @@ RUBY
     return trets
   end
 
+  def self.tc_send_class(trecv, e)
+    case trecv
+    when RDL::Type::SingletonType
+      if trecv.val.is_a? Class
+        [RDL::Type::SingletonType.new(Class)]
+      elsif trecv.val.is_a? Module
+        [RDL::Type::SingletonType.new(Module)]
+      else
+        [RDL::Type::SingletonType.new(trecv.val.class)]
+      end
+    when RDL::Type::NominalType
+      [RDL::Type::SingletonType.new(trecv.klass)]
+    when RDL::Type::GenericType
+      [RDL::Type::SingletonType.new(trecv.base.klass)]
+    when RDL::Type::TupleType
+      [RDL::Type::SingletonType.new(Array)]
+    when RDL::Type::FiniteHashType
+      [RDL::Type::SingletonType.new(Hash)]
+    when RDL::Type::VarType
+      error :recv_var_type, [trecv], e
+    when RDL::Type::MethodType
+      [RDL::Type::SingletonType.new(Proc)]
+    else
+      raise RuntimeError, "Unexpected receiver type #{trecv}"
+    end
+  end
+
   # [+ tmeth +] is MethodType
   # [+ actuals +] is Array<Type> containing the actual argument types
   # return instiation (possibly empty) that makes actuals match method type (if any), nil otherwise
@@ -1194,7 +1447,7 @@ RUBY
       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(targs))
-        _, body_type = if body.nil? then [nil, $__rdl_nil_type] else tc(bscope, env.merge(Env.new(targs)), body) end
+        _, body_type = if body.nil? then [nil, RDL::Globals.types[:nil]] else tc(bscope, env.merge(Env.new(targs)), body) end
         error :bad_return_type, [body_type, tblock.ret], body unless body.nil? || RDL::Type::Type.leq(body_type, tblock.ret, inst, false)
         #
       }
@@ -1223,7 +1476,7 @@ RUBY
         return t if k == klass && m = name
       }
     end
-    t = $__rdl_info.get_with_aliases(klass, name, :type)
+    t = RDL::Globals.info.get_with_aliases(klass, name, :type)
     return t if t # simplest case, no need to walk inheritance hierarchy
     the_klass = RDL::Util.to_class(klass)
     is_singleton = RDL::Util.has_singleton_marker(the_klass.to_s)
@@ -1234,11 +1487,11 @@ RUBY
       next if (ancestor.instance_of? Module) && (included.member? ancestor) && is_singleton
       # extended (i.e., not included) modules' instance methods get added as singleton methods, so can't be in class
       next if (ancestor.instance_of? Module) && (not (included.member? ancestor)) && (not is_singleton)
-      tancestor = $__rdl_info.get_with_aliases(ancestor.to_s, name, :type)
+      tancestor = RDL::Globals.info.get_with_aliases(ancestor.to_s, name, :type)
       return tancestor if tancestor
       # special caes: Kernel's singleton methods are *also* added when included?!
       if ancestor == Kernel
-        tancestor = $__rdl_info.get_with_aliases(RDL::Util.add_singleton_marker('Kernel'), name, :type)
+        tancestor = RDL::Globals.info.get_with_aliases(RDL::Util.add_singleton_marker('Kernel'), name, :type)
         return tancestor if tancestor
       end
       if ancestor.instance_methods(false).member?(name)
@@ -1255,56 +1508,66 @@ RUBY
   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",
-  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'",
-  puts_type_format: "puts_type must be called as `puts_type e'",
-  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'",
-  note_type: "Type is `%s'",
-  note_message: "%s",
-  recv_var_type: "receiver whose type is unconstrained variable `%s' not allowed",
-  type_args_more: "%s type accepts more arguments than actual %s definition",
-  type_args_fewer: "%s type accepts fewer arguments than actual %s definition",
-  type_arg_kind_mismatch: "%s type has %s argument but actual argument is %s",
-  type_args_no_kws: "%s type does not expect keyword arguments but actual expects keywords",
-  type_args_no_kw: "%s type does not expect keyword argument `%s'",
-  type_args_kw_mismatch: "%s type has %s keyword `%s' but actual argument is %s",
-  type_args_kw_more: "%s type expects keywords `%s' that are not expected by actual %s",
-  type_args_no_kw_rest: "%s type has no rest keyword but actual method accepts rest keywords",
-  type_args_kw_rest: "%s type has rest keyword but actual method does not accept rest keywords",
-  optional_default_type: "default value has type `%s' where type `%s' expected",
-  optional_default_kw_type: "default value for `%s' has type `%s' where type `%s' expected",
-  type_arg_block: "%s type does not expect block but actual %s takes block",
-  bad_block_arg_type: "block argument has type `%s' but expecting type `%s'",
-  non_block_block_arg: "block argument should have a block type but instead has type `%s'",
-  proc_block_arg_type: "block argument is a Proc; can't tell if it matches expected type `%s'",
-  no_type_for_symbol: "can't find type for method corresponding to `%s.to_proc'",
-}
-old_messages = Parser::MESSAGES
-Parser.send(:remove_const, :MESSAGES)
-Parser.const_set :MESSAGES, (old_messages.merge(type_error_messages))
+# Use parser's Diagnostic to output RDL typechecker error messages
+class Diagnostic < Parser::Diagnostic
+
+  def message
+    RDL_MESSAGES[@reason] % @arguments
+  end
+
+  RDL_MESSAGES = {
+    bad_return_type: "got type `%s' where return type `%s' expected",
+    bad_inst_type: "instantiate! called on object of type `%s' where Generic Type was expected",
+    inst_not_param: "instantiate! receiver is of class `%s' which is not parameterized",
+    inst_num_args: "instantiate! expecting `%s' type parameters, got `%s' parameters",
+    inst_lvar: "instantiate! expects local variable as receiver",
+    bad_initialize_type: 'initialize method must always be annotated to return type "self" or a GenericType where the base is "self"',
+    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' in class %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",
+    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 obj, type-string' or `type_cast obj, type-string, force: expr'",
+    instantiate_format: "instantiate! must be called as `instantiate! type*' or `instantiate! type*, check: bool' where type is a string, symbol, or class for static type checking.",
+    var_type_format: "var_type must be called as `var_type :var-name, type-string'",
+    puts_type_format: "puts_type must be called as `puts_type e'",
+    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'",
+    note_type: "Type is `%s'",
+    note_message: "%s",
+    recv_var_type: "receiver whose type is unconstrained variable `%s' not allowed",
+    type_args_more: "%s type accepts more arguments than actual %s definition",
+    type_args_fewer: "%s type accepts fewer arguments than actual %s definition",
+    type_arg_kind_mismatch: "%s type has %s argument but actual argument is %s",
+    type_args_no_kws: "%s type does not expect keyword arguments but actual expects keywords",
+    type_args_no_kw: "%s type does not expect keyword argument `%s'",
+    type_args_kw_mismatch: "%s type has %s keyword `%s' but actual argument is %s",
+    type_args_kw_more: "%s type expects keywords `%s' that are not expected by actual %s",
+    type_args_no_kw_rest: "%s type has no rest keyword but actual method accepts rest keywords",
+    type_args_kw_rest: "%s type has rest keyword but actual method does not accept rest keywords",
+    optional_default_type: "default value has type `%s' where type `%s' expected",
+    optional_default_kw_type: "default value for `%s' has type `%s' where type `%s' expected",
+    type_arg_block: "%s type does not expect block but actual %s takes block",
+    bad_block_arg_type: "block argument has type `%s' but expecting type `%s'",
+    non_block_block_arg: "block argument should have a block type but instead has type `%s'",
+    proc_block_arg_type: "block argument is a Proc; can't tell if it matches expected type `%s'",
+    no_type_for_symbol: "can't find type for method corresponding to `%s.to_proc'",
+  }
+end