rdl 2.0.0.rc2 → 2.0.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b977016fb74ea728b29a3eaa767aec63ee0d6a7b
-  data.tar.gz: 45b460bc49df3fca8248811e582617229142c35d
+  metadata.gz: 12683f52b0d365695fbbddde7ab7494ae049202e
+  data.tar.gz: 67d2aaf4bde9eba67027f5bc7662fd7d7e33c746
 SHA512:
-  metadata.gz: 2922f3d18c4c5398a520202d8930806545e05db55a449110a9837fef4c06293dc44ef98a3c3ca70a74c639d69114ae2d93f711ad0099dd11ae9ba730ab05b7b8
-  data.tar.gz: c36055f80360a2b6cdf4d732d7d7419e5783512b9d947f08ab933358d9ed0fef34c62fdb8b1d8ed2ec34d24f2cdcf9dd12c5cf03472b550714dce384ffa56cf6
+  metadata.gz: f42995d41cd05b3d9e1115c0cf7e20a4873f840659e9fd56e0f476941adac6dfef199dce88bacafdefaacbc3cf410be917fc6213b77ebe0a5428840e75721542
+  data.tar.gz: 0ee8aa838a19d9977acc2556bba2ef295bc8be97a6a6407af4a7882a2ecd62c09ef4d5b6464a61f49137d26751bd43c581df932e883424f96126847edf1606f9

data/CHANGES.md

@@ -2,11 +2,17 @@
 
 ## [Unreleased]
 ### Added
-- Added `wrap: false` optional argument to `type`, `pre`, and `post`
+- `wrap: false` optional argument to `type`, `pre`, and `post`
+- Non-null type annotation (not checked)
+- Default argument configuration for `type`, `pre`, and `post`
+- `attr_*_type` methods
+- Static type checking!
 
 ### Changed
 - Modified `self` type to be any instance of the self's class
 - Library types now use new aliases %integer and %numeric instead of the Integer and Numeric classes.
+- Fix issue #14 - allow type/pre/post to coexist, improve docs on dependent types
+- Fix typos in README, pull req #13
 
 ## [1.1.1] - 2016-05-21
 ### Fixed

data/README.md

@@ -8,6 +8,8 @@
   * [Supported versions of Ruby](#supported-versions-of-ruby)
   * [Installing RDL](#installing-rdl)
   * [Loading RDL](#loading-rdl)
+  * [Disabling RDL](#disabling-rdl)
+  * [Rails](#rails)
   * [Preconditions and Postconditions](#preconditions-and-postconditions)
   * [Type Annotations](#type-annotations)
 * [RDL Types](#rdl-types)
@@ -31,12 +33,15 @@
   * [Finite Hash Types](#finite-hash-types)
   * [Type Casts](#type-casts)
   * [Bottom Type (%bot)](#bottom-type-bot)
+  * [Non-null Type](#non-null-type)
 * [Static Type Checking](#static-type-checking)
   * [Types for Variables](#types-for-variables)
   * [Tuples, Finite Hashes, and Subtyping](#tuples-finite-hashes-and-subtyping)
   * [Other Features and Limitations](#other-features-and-limitations)
+  * [Assumptions](#assumptions)
 * [Other RDL Methods](#other-rdl-methods)
 * [Queries](#queries)
+* [Configuration](#configuration)
 * [Bibliography](#bibliography)
 * [Copyright](#copyright)
 * [Contributors](#contributors)
@@ -56,7 +61,7 @@ def sqrt(x)
 end
 ```
 
-Given this program, RDL intercepts the call to `sqrt` and passes its argument to the `pre` block, which checks that the arugment is positive. Then when `sqrt` returns, RDL passes the return value (as `r`) and the initial argument (as `x`) to the `post` block, which checks that the return is positive. (Let's ignore complex numbers to keep things simple...)
+Given this program, RDL intercepts the call to `sqrt` and passes its argument to the `pre` block, which checks that the argument is positive. Then when `sqrt` returns, RDL passes the return value (as `r`) and the initial argument (as `x`) to the `post` block, which checks that the return is positive. (Let's ignore complex numbers to keep things simple...)
 
 RDL contracts are enforced at method entry and exit. For example, if we call `sqrt(49)`, RDL first checks that `49 > 0`; then it passes `49` to `sqrt`, which (presumably) returns `7`; then RDL checks that `7 > 0`; and finally it returns `7`.
 
@@ -111,7 +116,7 @@ See below for more details of the query format. The `rdl_query` method performs
 $ irb
 > require 'rdl'
  => true
-> require 'rdl_types'
+> require 'types/core'
  => true
 
 > rdl_query '...' # as above
@@ -137,17 +142,13 @@ Use `require 'rdl'` to load the RDL library. If you want to use the core and sta
 
 (Currently all these are assumed to have the same library type signatures, which may not be correct.)
 
-If you're using Ruby on Rails, you can similarly `require 'rails_types'` to load in type annotations for the current `Rails::VERSION::STRING`. More specifically, add the following lines in `application.rb` after the `Bundler.require` call. (This placement is needed so the Rails version string is available and the Rails environment is loaded):
+## Disabling RDL
 
-```ruby
-require 'rdl'
-require 'rdl_types'
-require 'rails_types'
-```
+For performance reasons you probably don't want to use RDL in production code. To disable RDL, replace `require 'rdl'` with `require 'rdl_disable'`. This will cause all invocations of RDL methods to either be no-ops or to do the minimum necessary to preserve the program's semantics (e.g., if the RDL method returns `self`, then so does the `rdl_disable` method.)
 
-Currently RDL has types for the following versions of Rails:
+## Rails
 
-* Rails support is currently almost non-existent; more coming in the future
+To use RDL with Rails, use the [rdl-rails](https://github.com/plum-umd/rdl-rails) gem.
 
 ## Preconditions and Postconditions
 
@@ -300,7 +301,7 @@ Here we've named the first argument of `to_s` as `base` to give some extra hint
 
 ## Dependent Types
 
-RDL allows for refinement predicates to be attached to named arguments. These predicates are then checked when the method is called and returns. For instance:
+RDL allows for refinement predicates to be attached to named arguments. The predicates on the arguments are checked when the method is called, and the predicates on the return is checked when then method returns. For instance:
 
 ```ruby
 type '(Float x {{ x>=0 }}) -> Float y {{ y>=0 }}'
@@ -318,7 +319,13 @@ type '(Fixnum x {{ x>y }}, Fixnum y) -> Float z {{ z==(x+y) }}'
 def m(x,y) ... end
 ```
 
-Any arbitrary code can be placed between the double braces of a type refinement, and RDL will dynmically check that this predicate evaluates to true, or raise a type error if it evaluates to false.
+Any arbitrary code can be placed between the double braces of a type refinement, and RDL will dynamically check that this predicate evaluates to true, or raise a type error if it evaluates to false.
+
+Most pre- and postconditions can be translated into a dependent type by attaching the precondition to one of the arguments and the postcondition to the return. Note, however, that dependently typed positions must always have a name, even if the associated refinment doesn't refer to that name:
+
+```ruby
+type '(Fixnum x {{ $y > 0 }}) -> nil'    # argument name must be present even though refinment doesn't use it.
+```
 
 ## Higher-order Types
 
@@ -352,7 +359,7 @@ type '(Fixnum x, Float y) -> {(Fixnum z {{ z>y }}) -> Fixnum}'
 def m(x,y,&blk) ... end
 ```
 
-The type contract above states that method `m` returns a `Proc` which takes a `Fixnum z` which must be greater than the argument `Float y`. Whenver this `Proc` is called, it will be checked that this contract holds.
+The type contract above states that method `m` returns a `Proc` which takes a `Fixnum z` which must be greater than the argument `Float y`. Whenever this `Proc` is called, it will be checked that this contract holds.
 
 ## Class/Singleton Method Types
 
@@ -485,7 +492,7 @@ To fully enforce generic types, RDL requires that the developer `instantiate!` a
 
 ```ruby
 x = [1,2]
-x.instantate!('Fixnum')
+x.instantiate!('Fixnum')
 x.push("three") # type error
 ```
 
@@ -514,7 +521,7 @@ The rules for variances are standard. Let's assume `A` is a subclass of `B`. Als
 
 ## Tuple Types
 
-A type such as `Array<Fixnum>` is useful for homogeneous arrays, where all elements have the same type. But Ruby programs often use heterogenous arrays, e.g., `[1, "two"]`. The best generic type we can give this is `Array<Fixnum or String>`, but that's imprecise.
+A type such as `Array<Fixnum>` is useful for homogeneous arrays, where all elements have the same type. But Ruby programs often use heterogeneous arrays, e.g., `[1, "two"]`. The best generic type we can give this is `Array<Fixnum or String>`, but that's imprecise.
 
 RDL includes special *tuple types* to handle this situation. Tuple types are written `[t1, ..., tn]`, denoting an `Array` of `n` elements of types `t1` through `tn`, in that order. For example, `[1, "two"]` has type `[Fixnum, String]`. As another example, here is the type of `Process#getrlimit`, which returns a two-element array of `Fixnums`:
 
@@ -524,7 +531,7 @@ type Process, 'self.getrlimit', '(Symbol or String or Fixnum resource) -> [Fixnu
 
 ## Finite Hash Types
 
-Similarly to tuple types, RDL also supports *finite hash types* for heterogenous hashes. Finite hash types are written `{k1 => v1, ..., kn => vn}` to indicate a `Hash` with `n` mappings of type `ki` maps to `vi`. The `ki` may be strings, integers, floats, or constants denoted with `${.}`. If a key is a symbol, then the mapping should be written `ki: vi`. In the latter case, the `{}`'s can be left off:
+Similarly to tuple types, RDL also supports *finite hash types* for heterogeneous hashes. Finite hash types are written `{k1 => v1, ..., kn => vn}` to indicate a `Hash` with `n` mappings of type `ki` maps to `vi`. The `ki` may be strings, integers, floats, or constants denoted with `${.}`. If a key is a symbol, then the mapping should be written `ki: vi`. In the latter case, the `{}`'s can be left off:
 ```ruby
 type MyClass, :foo, '(a: Fixnum, b: String) { () -> %any } -> %any'
 ```
@@ -538,15 +545,42 @@ Sometimes RDL does not have precise information about an object's type (this is
 
 RDL also includes a special *bottom* type `%bot` that is a subtype of any type, including any class and any singleton types. In static type checking, the type `%bot` is given to so-called *void value expressions*, which are `return`, `break`, `next`, `redo`, and `retry` (notice that these expressions perform jumps rather than producing a value, hence they can be treated as having an arbitrary type). No Ruby objects have type `%bot`.
 
+## Non-null Type
+
+Types can be prefixed with `!` to indicate the associated value is not `nil`. For example:
+
+`type :x=, '(!Fixnum) -> !Fixnum'  # x's argument must not be nil`
+
+**Warning:** This is simply *documentation* of non-nullness, and **is not checked** by the static type checker. The contract checker might or might not enforce non-nullness. (For those who are curious: RDL has this annotation because it seems useful for descriptive purposes. However, it's quite challenging to build a practical analysis that enforces non-nilness without reporting too many false positives.)
+
 # Static Type Checking
 
 RDL has experimental support (note: this is in beta release) for static type checking. As mentioned in the introduction, calling `type` with `typecheck: :now` statically type checks the body of the annotated method body against the given signature. If the method has already been defined, RDL will try to check the method immediately. Otherwise, RDL will statically type check the method as soon as it is loaded.
 
 Often method bodies cannot be type checked as soon as they are loaded because they refer to classes, methods, and variables that have not been created yet. To support these cases, some other symbol can be supplied as `typecheck: sym`. Then when `rdl_do_typecheck sym` is called, all methods typechecked at `sym` will be statically checked.
 
-Addditionally, `type` can be called with `typecheck: :call`, which will delay checking the method's type until the method is called. Currently these checks are not cached, so expect a big performance hit for using this feature.
+Additionally, `type` can be called with `typecheck: :call`, which will delay checking the method's type until the method is called. Currently these checks are not cached, so expect a big performance hit for using this feature.
+
+To perform type checking, RDL needs source code, which it gets by parsing the file containing the to-be-typechecked method. Hence, static type checking does not work in `irb` since RDL has no way of getting the source.
+
+Typechecking does work in `pry` (this feature has only limited testing) as long as typechecking is delayed until after the method is defined:
+
+```ruby
+[2] pry(main)> require 'rdl'
+[3] pry(main)> require 'rdl_types'
+[4] pry(main)> type '() -> Fixnum', typecheck: :later    # note: typecheck: :now doesn't work in pry
+[5] pry(main)> def f
+[5] pry(main)*   'haha'  
+[5] pry(main)* end  
+[6] pry(main)> rdl_do_typecheck :later
+RDL::Typecheck::StaticTypeError:
+(string):2:3: error: got type `String' where return type `Fixnum' expected
+(string):2:   'haha'
+(string):2:   ^~~~~~
+from .../typecheck.rb:158:in `error'
+```
 
-To perform type checking, RDL needs source code, which it gets by parsing the file containing the to-be-typechecked method. Hence, static type checking does not work in `irb` since RDL has no way of getting the source. RDL currently uses the [parser Gem](https://github.com/whitequark/parser) to parse Ruby source code. (And RDL uses the parser gem's amazing diagnostic output facility to print type error messages.)
+RDL currently uses the [parser Gem](https://github.com/whitequark/parser) to parse Ruby source code. (And RDL uses the parser gem's amazing diagnostic output facility to print type error messages.)
 
 Next we discuss some special features of RDL's type system and some of its limitations.
 
@@ -575,7 +609,15 @@ x = 3       # okay
 x = "three" # type error
 ```
 
-The first argument to `var_type` is a symbol with the local variable name, and the second argument is a string containing the variable's type. Note that `var_type` is most useful at the beginning of method or code block. Using it elsewhere may result in surprising error mesages, since RDL requires variables with fixed types to have the same type along all paths. Method parameters are treated as if `var_type` was called on them at the beginning of the method, fixing them to their declared type. This design choice may be revisited in the future.
+The first argument to `var_type` is a symbol with the local variable name, and the second argument is a string containing the variable's type. Note that `var_type` is most useful at the beginning of method or code block. Using it elsewhere may result in surprising error messages, since RDL requires variables with fixed types to have the same type along all paths. Method parameters are treated as if `var_type` was called on them at the beginning of the method, fixing them to their declared type. This design choice may be revisited in the future.
+
+There is one subtlety for local variables and code blocks. Consider the following code:
+```ruby
+x = 1
+m() { x = 'bar' }
+# what is x's type here?
+```
+If `m` invokes the code block, `x` will be a `String` after the call. Otherwise `x` will be `1`. Since RDL can't tell whether the code block is ever called, it assigns `x` type `1 or String`. It's actually quite tricky to do very precise reasoning about code blocks. For example, `m` could (pathologically) store its block in a global variable and then only call it the second time `m` is invoked. To keep its reasoning simple, RDL treats any local variables captured (i.e., imported from an outer scope) by a code block flow-insensitively for the lifetime of the method. The type of any such local variables is the union of all types that are ever assigned to it.
 
 RDL always treats instance, class, and global variables flow-insensitively, hence their types must be defined with `var_type`:
 
@@ -636,13 +678,15 @@ RDL uses the same approach for hashes: hash literals are treated as finite hashe
 
 ## Other Features and Limitations
 
+*Displaying types.* As an aid to debugging, the method `rdl_note_type e` will display the type of `e` during type checking. At run time, this method returns its argument. Note that in certain cases RDL may type check the same code repeatedly in which case an expression's type could be printed multiple times.
+
 * *Conditional guards and singletons.* If an `if` or `unless` guard has a singleton type, RDL will typecheck both branches but not include types from the unrealizable branch in the expression type. For example, `if true then 1 else 'two' end` has type `1`. RDL behaves similarly for `&&` and `||`. However, RDL does not implement this logic for `case`.
 
 * *Multiple Assignment and nil.* In Ruby, extra left-hand sides of multiple assignments are set to `nil`, e.g., `x, y = [1]` sets `x` to `1` and `y` to `nil`. However, RDL reports an error in this case; this may change in the future.
 
 * *Block formal arguments.* Similarly, RDL reports an error if a block is called with the wrong number of arguments even though Ruby does not signal an error in this case.
 
-* *Caching.* If `typecheck: true` is specified on a method, Ruby will type check the method every time it is called. In the future, RDL will cache these checks.
+* *Caching.* If `typecheck: :call` is specified on a method, Ruby will type check the method every time it is called. In the future, RDL will cache these checks.
 
 * *Unsupported Features.* There are several features of Ruby that are currently not handled by RDL. Here is a non-exhaustive list:
   * `super` is not supported.
@@ -651,6 +695,14 @@ RDL uses the same approach for hashes: hash literals are treated as finite hashe
   * Control flow for exceptions is not analyzed fully soundly; some things are not reported as possibly `nil` that could be.
   * Only simple usage of constants is handled.
 
+## Assumptions
+
+RDL makes some assumptions that should hold unless your Ruby code is doing something highly unusual:
+
+* `Class#===` is not redefined
+
+(More assumptions will be added here as they are added to RDL...)
+
 # Other RDL Methods
 
 RDL also includes a few other useful methods:
@@ -659,6 +711,8 @@ RDL also includes a few other useful methods:
 
 * `rdl_nowrap`, if called at the top-level of a class, causes RDL to behave as if `wrap: false` were passed to all `type`, `pre`, and `post` calls in the class. This is mostly used for the core and standard libraries, which have trustworthy behavior hence enforcing their types and contracts is not worth the overhead.
 
+* `rdl_remove_type klass, meth` removes the type annotation for meth in klass. Fails if meth does not have a type annotation.
+
 * `rdl_query` prints information about types; see below for details.
 
 # Queries
@@ -711,6 +765,26 @@ $ rdl_query "(.?) -> ."                # methods that take one, optional argumen
 
 Note that aside from `.` and `...`, the matching is exact. For example `(Fixnum) -> Fixnum` will not match a method of type `(Fixnum or String) -> Fixnum`.
 
+# Configuration
+
+To configure RDL, execute the following shortly after RDL is loaded:
+
+```ruby
+RDL.config { |config|
+  # use config to configure RDL here
+}
+```
+
+RDL supports the following configuration options:
+
+* `config.nowrap` - `Array<Class>` containing all classes whose methods should not be wrapped.
+* `config.gather_stats` - currently disabled.
+* `config.report` - if true, then when the program exits, RDL will print out a list of methods that were statically type checked, and methods that were annotated to be statically type checked but weren't.
+* `config.guess_types` - List of classes (of type `Array<Symbol>`). For every method added to a listed class *after* this configuration option is set, RDL will record the types of its arguments and returns at run-time. Then when the program exits, RDL will print out a skeleton for each class with types for the monitored methods based on what RDL recorded at run-time and based on what Ruby knows about the methods' signatures. This is probably not going to produce the correct method types, but it might be a good starting place.
+* `config.type_defaults` - Hash containing default options for `type`. Initially `{ wrap: true, typecheck: false }`.
+* `config.pre_defaults` - Hash containing default options for `pre`. Initially `{ wrap: true }`.
+* `config.post_defaults` - same as `pre_defaults`, but for `post`.
+
 # Bibliography
 
 Here are some research papers we have written exploring contracts, types, and Ruby.

data/lib/rdl.rb

@@ -19,6 +19,8 @@ require 'rdl/info.rb'
 #   :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
@@ -59,13 +61,14 @@ 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/finite_hash.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/non_null.rb'
 require 'rdl/types/optional.rb'
 require 'rdl/types/parser.tab.rb'
 require 'rdl/types/structural.rb'

data/lib/rdl/config.rb

@@ -6,11 +6,17 @@ class RDL::Config
   attr_accessor :nowrap
   attr_accessor :gather_stats
   attr_accessor :report
+  attr_accessor :guess_types
+  attr_accessor :type_defaults, :pre_defaults, :post_defaults
 
   def initialize
     @nowrap = Set.new
     @gather_stats = false
     @report = false
+    @guess_types = []
+    @type_defaults = { wrap: true, typecheck: false }
+    @pre_defaults = { wrap: true }
+    @post_defaults = { wrap: true }
   end
 
   def add_nowrap(*klasses)
@@ -120,10 +126,10 @@ RDL::Config.instance.profile_stats
 
     Profiler__.start_profile # Restart profiler after setup
   end
-end
 
-at_exit do
-  if RDL::Config.instance.report
+  def do_report
+    return unless @report
+    puts "------------------------------"
     typechecked = []
     missing = []
     $__rdl_info.info.each_pair { |klass, meths|
@@ -149,4 +155,85 @@ at_exit do
       missing.each { |klass, meth| puts RDL::Util.pp_klass_method(klass, meth) }
     end
   end
+
+  def guess_meth(klass, meth, is_sing, the_meth)
+    # first print based on signature according to Ruby
+    first = true
+    block = false
+    print "  type #{if is_sing then '\'self.' + meth + '\'' else ':' + meth end}, '("
+    params = the_meth.parameters
+    params.each_with_index { |param, i|
+      kind, name = param
+      print ", " unless first || kind == :block
+      case kind
+      when :req
+        print "XXXX #{name}"
+      when :opt
+        print "?XXXX #{name}"
+      when :rest
+        print "*#XXXX #{name}"
+      when :key
+        print "#{name}: XXXX"
+      when :block
+        block = true
+      else
+        print "???? param of kind #{kind} for #{name}"
+      end
+      first = false
+    }
+    print ")"
+    print " { BLOCK }" if block
+    puts " -> XXXX'"
+
+    # next print based on observed types
+    otypes = $__rdl_info.get(klass, meth, :otype) if $__rdl_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
+    otblock = false
+    otypes.each { |ot|
+      ot[:args].each_with_index { |t, i|
+        otargs[i] = $__rdl_bot_type 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
+      otblock = otblock || ot[:block]
+    }
+    otargs.each { |t|
+      print ", " unless first
+      print t
+      first = false
+    }
+    print ")"
+    print " { BLOCK }" if otblock
+    puts " -> #{otret}'"
+  end
+
+  def do_guess_types
+    return if @guess_types.empty?
+    puts "------------------------------"
+    puts "TYPE GUESSES"
+    RDL::Config.instance.guess_types.each { |klass|
+      puts
+      puts "class #{klass}"
+      the_klass = RDL::Util.to_class(klass)
+      sklass = RDL::Util.add_singleton_marker(klass.to_s)
+      the_klass.singleton_methods(false).each { |meth|
+        next unless meth.to_s =~ /^__rdl_(.*)_old/
+        guess_meth(sklass, $1, true, the_klass.singleton_method(meth))
+      }
+      the_klass.instance_methods(false).each { |meth|
+        next unless meth.to_s =~ /^__rdl_(.*)_old/
+        guess_meth(klass, $1, false, the_klass.instance_method(meth))
+      }
+      puts "end"
+    }
+  end
+end
+
+at_exit do
+  RDL::Config.instance.do_report
+  RDL::Config.instance.do_guess_types
 end

data/lib/rdl/info.rb

@@ -71,4 +71,20 @@ class RDL::Info
     return t2[kind]
 #    return @info[klass][label][kind]
   end
+
+  def get_with_aliases(klass, label, kind)
+    while $__rdl_aliases[klass] && $__rdl_aliases[klass][label]
+      label = $__rdl_aliases[klass][label]
+    end
+    get(klass, label, kind)
+  end
+
+  def remove(klass, label, kind)
+    klass = klass.to_s
+    label = label.to_sym
+    return unless @info.has_key? klass
+    return unless @info[klass].has_key? label
+    @info[klass][label].delete kind
+  end
+
 end

data/lib/rdl/typecheck.rb

@@ -65,8 +65,9 @@ module RDL::Typecheck
       return @env[var][:type]
     end
 
-    def bind(var, typ)
-      raise RuntimeError, "Can't update variable with fixed type" if @env[var] && @env[var][:fixed]
+    # force should only be used with care! currently only used when type is being refined to a subtype in a lexical scope
+    def bind(var, typ, force: false)
+      raise RuntimeError, "Can't update variable with fixed type" if !force && @env[var] && @env[var][:fixed]
       result = Env.new
       result.env = @env.merge(var => {type: typ, fixed: false})
       return result
@@ -132,7 +133,6 @@ module RDL::Typecheck
     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)
@@ -144,15 +144,40 @@ module RDL::Typecheck
     return r
   end
 
+  # add x:t to the captured map in scope
+  def self.capture(scope, x, t)
+    if scope[:captured][x]
+      scope[:captured][x] = RDL::Type::UnionType.new(scope[:captured][x], t).canonical unless t <= scope[:captured][x]
+    else
+      scope[:captured][x] = t
+    end
+  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)
+  def self.note(reason, args, ast)
+    puts (Parser::Diagnostic.new :note, reason, args, ast.loc.expression).render
+  end
+
+  def self.get_ast(klass, meth)
     file, line = $__rdl_info.get(klass, meth, :source_location)
-    raise RuntimeError, "static type checking in irb not supported" if file == "(irb)"
     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)"
+      # no caching...
+      if RDL::Wrap.wrapped?(klass, meth)
+        meth_name = RDL::Wrap.wrapped_name(klass, meth)
+      else
+        meth_name = meth
+      end
+      the_meth = RDL::Util.to_class(klass).instance_method(meth_name)
+      code = Pry::Code.from_method the_meth
+      return Parser::CurrentRuby.parse code.to_s
+    end
+
     digest = Digest::MD5.file file
     cache_hit = (($__rdl_ruby_parser_cache.has_key? file) &&
                  ($__rdl_ruby_parser_cache[file][0] == digest))
@@ -165,6 +190,11 @@ module RDL::Typecheck
     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?
+    return ast
+  end
+
+  def self.typecheck(klass, meth)
+    ast = get_ast(klass, meth)
     types = $__rdl_info.get(klass, meth, :type)
     raise RuntimeError, "Can't typecheck method with no types?!" if types.nil? or types == []
 
@@ -176,6 +206,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)
     types.each { |type|
       # TODO will need fancier logic here for matching up more complex arg lists
       if RDL::Util.has_singleton_marker(klass)
@@ -189,10 +220,17 @@ module RDL::Typecheck
       unless type.args.length == args.children.length
         error :arg_count_mismatch, ['method', type.args.length, 'method', args.children.length], (if args.children.empty? then ast else args end)
       end
-      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
+      targs = args.children.map { |arg| arg.children[0] }.zip(type.args).to_h
+      targs[:self] = self_type
+      scope = { tret: type.ret, tblock: type.block, captured: Hash.new, context_types: context_types }
+      begin
+        old_captured = scope[:captured].dup
+        if body.nil?
+          body_type = $__rdl_nil_type
+        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
     }
     $__rdl_info.set(klass, meth, :typechecked, true)
@@ -315,7 +353,7 @@ module RDL::Typecheck
       # 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
+      error :nonmatching_range_type, [t1, t2], e unless t1 <= t2 || t2 <= t1
       [env2, RDL::Type::GenericType.new($__rdl_range_type, t1)]
     when :self
       [env, env[:self]]
@@ -452,8 +490,9 @@ module RDL::Typecheck
       # 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_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?
       envi = env
       tactuals = []
       block = scope[:block]
@@ -464,7 +503,7 @@ module RDL::Typecheck
             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)
+              tactuals << RDL::Type::VarargType.new(ti.params[0]) # Turn Array<t> into *t
             else
               error :cant_splat, [ti], ei.children[0]
             end
@@ -537,12 +576,38 @@ RUBY
       e.children[1..-2].each { |wclause|
         raise RuntimeError, "Don't know what to do with case clause #{wclause.type}" unless wclause.type == :when
         envguards = []
+        tguards = []
         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
+          tguards << tguard
           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
+        initial_env = Env.join(e, *envguards)
+        if (tguards.all? { |t| t.is_a?(RDL::Type::SingletonType) && t.val.is_a?(Class) }) && (e.children[0].type == :lvar)
+          # Special case! We're branching on the type of the guard, which is a local variable.
+          # So rebind that local variable to have the union of the guard types
+          new_typ = RDL::Type::UnionType.new(*(tguards.map { |t| RDL::Type::NominalType.new(t.val) })).canonical
+          # TODO adjust following for generics!
+          if tcontrol.is_a? RDL::Type::GenericType
+            if new_typ == tcontrol.base
+              # special case: exact match of control type's base and type of guard; can use
+              # geneirc type on this branch
+              initial_env = initial_env.bind(e.children[0].children[0], tcontrol, force: true)
+            elsif !(tcontrol.base <= new_typ) && !(new_typ <= tcontrol.base)
+              next # can't possibly match this branch
+            else
+              error :generic_error, ["general refinement for generics not implemented yet"], wclause
+            end
+          else
+            next unless tcontrol <= new_typ || new_typ <= tcontrol # If control can't possibly match type, skip this branch
+            initial_env = initial_env.bind(e.children[0].children[0], new_typ, force: true)
+            # note force is safe above because the env from this arm will be joined with the other envs
+            # (where the type was not refined like this), so after the case the variable will be back to its
+            # previous, unrefined type
+          end
+        end
+        envbody, tbody = tc(scope, initial_env, wclause.children[-1]) # last wclause child is body
         tbodies << tbody
         envbodies << envbody
       }
@@ -600,6 +665,7 @@ RUBY
         [lscope[:break], lscope[:tbreak].canonical]
       }
     when :for
+      # (for (lvasgn var) collection body)
       # break: loop exit, which is same as top of body, arg allowed
       # next: top of body, arg allowed
       # retry: not allowed
@@ -607,21 +673,18 @@ RUBY
       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])
+        teaches = lookup(scope, 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])
+        teaches = lookup(scope, tcollect.base.name, :each, e.children[1])
         inst = tcollect.to_inst.merge(self: tcollect)
         teaches = teaches.map { |t| t.instantiate(inst) }
       else
@@ -639,7 +702,7 @@ RUBY
         break
       }
       error :no_each_type, [tcollect.name], e.children[1] if teach.nil?
-      envi = envi.bind(x, teach.block.args[0])
+      envi, _ = tc_vasgn(scope, envi, :lvasgn, x, teach.block.args[0], e.children[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
@@ -741,10 +804,15 @@ RUBY
     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
+      capture(scope, name, env[name].canonical) if scope[:outer_env] && (scope[:outer_env].has_key? name) && (not (scope[:outer_env].fixed? name))
+      # if scope[:outer_env] && (scope[:outer_env].has_key? name) && (not (scope[:outer_env].fixed? name))
+      #   error :nonlocal_access, [name], e
+      # end
+      if scope[:captured] && scope[:captured].has_key?(name) then
+        [env, scope[:captured][name]]
+      else
+        [env, env[name].canonical]
       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)
@@ -764,10 +832,11 @@ RUBY
   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
+      if ((scope[:captured] && scope[:captured].has_key?(name)) ||
+          (scope[:outer_env] && (scope[:outer_env].has_key? name) && (not (scope[:outer_env].fixed? name))))
+        capture(scope, name, tright.canonical)
+        [env, scope[:captured][name]]
+      elsif (env.fixed? name)
         error :vasgn_incompat, [tright, env[name]], e unless tright <= env[name]
         [env, tright.canonical]
       else
@@ -787,8 +856,17 @@ RUBY
     when :send
       meth = e.children[1] # note method name include =!
       envi, trecv = tc(scope, env, e.children[0]) # receiver
+      typs = []
+      if e.children.length > 2
+        # special case of []= when there's a second arg (the index)
+        # this code is a little more general than it has to be unless other similar operators added
+        e.children[2..-1].each { |arg|
+          envi, targ = tc(scope, envi, arg)
+          typs << targ
+        }
+      end
       # name is not useful here
-      [envi, tc_send(scope, envi, trecv, meth, [tright], nil, e)] # call receiver.meth(tright)
+      [envi, tc_send(scope, envi, trecv, meth, [*typs, tright], nil, e)] # call receiver.meth(other args, tright)
     else
       raise RuntimeError, "unknown kind #{kind}"
     end
@@ -796,7 +874,7 @@ RUBY
 
   # [+ e +] is the method call
   def self.tc_var_type(scope, env, e)
-    error :var_type_format, [], e unless e.children.length == 4
+    error :var_type_format, [], e unless e.children.length == 4 && scope[:block].nil?
     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)
@@ -829,6 +907,13 @@ RUBY
     [env1, typ]
   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]
+    [env, 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.
@@ -860,20 +945,20 @@ RUBY
     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 = lookup(scope, 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)
+        ts = lookup(scope, 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)
+      ts = lookup(scope, 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) }
@@ -882,20 +967,38 @@ RUBY
         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)
+      ts = lookup(scope, 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) }
+    when RDL::Type::VarType
+      error :recv_var_type, [trecv], e
     else
-      raise RuntimeError, "receiver type #{t} not supported yet"
+      raise RuntimeError, "receiver type #{trecv} 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
+
+    # for ALL of the expanded lists of actuals...
+    RDL::Type.expand_product(tactuals).each { |tactuals_expanded|
+      # AT LEAST ONE of the possible intesection arms must match
+      trets_tmp = []
+      tmeth_inter.each { |tmeth| # MethodType
+        if ((tmeth.block && block) || (tmeth.block.nil? && block.nil?))
+          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
+          end
+        end
+      }
+      if trets_tmp.empty?
+        # no arm of the intersection matched this expanded actuals lists, so reset trets to signal error and break loop
+        trets = []
+        break
+      else
+        trets.concat(trets_tmp)
       end
     }
     if trets.empty? # no possible matching call
@@ -910,10 +1013,10 @@ RUBY
         :initialize
       elsif trecv.is_a? RDL::Type::SingletonType
         trecv.val.class.to_s
-      elsif trecv.is_a? RDL::Type::NominalType
-        trecv.name
+      elsif (trecv.is_a? RDL::Type::NominalType) || (trecv.is_a? RDL::Type::GenericType)
+        trecv.to_s
       else
-        raise RutimeError, "impossible"
+        raise RuntimeError, "impossible to get type #{trecv}"
       end
       error :arg_type_single_receiver_error, [name, meth, msg], e
     end
@@ -923,15 +1026,16 @@ RUBY
 
   # [+ tmeth +] is MethodType
   # [+ actuals +] is Array<Type> containing the actual argument types
-  # return true if actuals match method type, false otherwise
+  # return instiation (possibly empty) that makes actuals match method type (if any), nil otherwise
   # Very similar to MethodType#pre_cond?
   def self.tc_arg_types(tmeth, tactuals)
-    states = [[0, 0]] # position in tmeth, position in tactuals
+    states = [[0, 0, Hash.new]] # position in tmeth, position in tactuals, inst of free vars in tmeth
     tformals = tmeth.args
     until states.empty?
-      formal, actual = states.pop
+      formal, actual, inst = states.pop
+      inst = inst.dup # avoid aliasing insts in different states since Type.leq mutates inst arg
       if formal == tformals.size && actual == tactuals.size # Matched everything
-        return true
+        return inst
       end
       next if formal >= tformals.size # Too many actuals to match
       t = tformals[formal]
@@ -940,60 +1044,64 @@ RUBY
       end
       case t
       when RDL::Type::OptionalType
-        t = t.type #TODO .instantiate(inst)
+        t = t.type
         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
+          states << [formal+1, actual, inst] # skip over optinal formal
+        elsif (not (tactuals[actual].is_a?(RDL::Type::VarargType))) && RDL::Type::Type.leq(tactuals[actual], t, inst, false)
+          states << [formal+1, actual+1, inst] # match
+          states << [formal+1, actual, inst] # skip
         else
-          states << [formal+1, actual] # types don't match; must skip this formal
+          states << [formal+1, actual, inst] # 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!
+          states << [formal+1, actual, inst] # skip to allow empty vararg at end
+        elsif (not (tactuals[actual].is_a?(RDL::Type::VarargType))) && RDL::Type::Type.leq(tactuals[actual], t.type, inst, false)
+          states << [formal, actual+1, inst] # match, more varargs coming
+          states << [formal+1, actual+1, inst] # match, no more varargs
+          states << [formal+1, actual, inst] # skip over even though matches
+        elsif tactuals[actual].is_a?(RDL::Type::VarargType) && RDL::Type::Type.leq(tactuals[actual].type, t.type, inst, false) &&
+                                                               RDL::Type::Type.leq(t.type, tactuals[actual].type, inst, true)
+          states << [formal+1, actual+1, inst] # match, no more varargs; no other choices!
         else
-          states << [formal+1, actual] # doesn't match, must skip
+          states << [formal+1, actual, inst] # 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]
+            states << [formal+1, actual, inst]
           end
-        elsif (not (tactuals[actual].is_a?(RDL::Type::VarargType))) && tactuals[actual] <= t
-          states << [formal+1, actual+1] # match!
+        elsif (not (tactuals[actual].is_a?(RDL::Type::VarargType))) && RDL::Type::Type.leq(tactuals[actual], t, inst, false)
+          states << [formal+1, actual+1, inst] # match!
           # no else case; if there is no match, this is a dead end
         end
       end
     end
-    false
+    return nil
   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)
+  def self.tc_block(scope, env, tblock, block, inst)
     # 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
+    unless tblock.args.length == args.children.length
+      error :arg_count_mismatch, ['block', tblock.args.length, 'block', args.children.length], (if block[0].children.empty? then block[1] else block[0] end)
+    end
+    tblock = tblock.instantiate(inst)
     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
+      error :bad_return_type, [body_type, tblock.ret], body unless body.nil? || RDL::Type::Type.leq(body_type, tblock.ret, inst, false)
+      #
     }
   end
 
@@ -1001,24 +1109,40 @@ RUBY
   # [+ 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)
+  # types in scope[:context_type] take precedence
+
+  # *always* included module's instance methods only
+  # if included, those methods are added to instance_methods
+  # if extended, those methods are added to singleton_methods
+  def self.lookup(scope, klass, name, e)
+    if scope[:context_types]
+      # return array of all matching types from context_types, if any
+      ts = []
+      scope[:context_types].each { |ctk, ctm, ctt| ts << ctt if ctk.to_s == klass && ctm == name  }
+      return ts unless ts.empty?
+    end
+    return scope[:context_types][klass][name] if scope[:context_types] && scope[:context_types][klass] && scope[:context_types][klass][name]
+    t = $__rdl_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)
     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)
+      # included modules' instance methods get added as instance methods, so can't be in singleton class
+      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)
       return tancestor if tancestor
-      if (if RDL::Util.has_singleton_marker(ancestor_name) then ancestor.singleton_methods(false).member?(name) else ancestor.instance_methods(false).member?(name) end)
+      # 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)
+        return tancestor if tancestor
+      end
+      if ancestor.instance_methods(false).member?(name)
         klass = RDL::Util.remove_singleton_marker klass if RDL::Util.has_singleton_marker klass
-        error :missing_ancestor_type, [ancestor_name, klass, name], e
+        error :missing_ancestor_type, [ancestor, klass, name], e
       end
     }
     return nil
@@ -1050,12 +1174,16 @@ type_error_messages = {
   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')",
+  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",
 }
 old_messages = Parser::MESSAGES
 Parser.send(:remove_const, :MESSAGES)