rdl 2.0.0.rc4 → 2.0.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 036f7f5447f5a5405a0624b7f346101e19012c19
-  data.tar.gz: 3004e573e29f44e4adea3c2b1cdc314134fa4f4f
+  metadata.gz: 37bb60eb1678b69aca3b6967c386f31c2d0c882f
+  data.tar.gz: 8824ba76d0daa9d4049df6d4677846386e5c6733
 SHA512:
-  metadata.gz: 0355d89a993299da187c096dd85b27209205a0155c80780944c88118a775e2b82f6f9746536465f8f096a8197ebfd1084f64c613f90a1319e2a31b88f5b1645a
-  data.tar.gz: db84c871660e4e4e6458d31f11bef1ed5a68056d3ac5dd8fd293e85b5b189cc9431c359c28a1db41fc3dd27244835f854aa8aa287a5873786bb0f4b7a72b72b9
+  metadata.gz: 593c30a12e453dc79c796b65c8598c345b0bb562978fb4a21fcb903c9a8d0fffcbc0b0534bb0187933ae8399c9dc8022bac689c77601282f442bb687dc79d985
+  data.tar.gz: 4daaeafc5cc639db5afe714c9b4c71a8f9455dea7d8151741f3dcd914f384ca728389cc9f1931a255e97513be9b2423c7a0773dc09eba8959905fdfc6a568658

data/README.md

@@ -49,23 +49,7 @@
 
 # Introduction
 
-RDL is a lightweight system for adding contracts to Ruby. A *contract* decorates a method with assertions describing what the method assumes about its inputs (called a *precondition*) and what the method guarantees about its outputs (called a *postcondition*). For example, using RDL we can write
-
-```ruby
-require 'rdl'
-
-pre { |x| x > 0 }
-post { |r,x| r > 0 }
-def sqrt(x)
-  # return the square root of x
-end
-```
-
-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`.
-
-In addition to arbitrary pre- and post-conditions, RDL also has extensive support for contracts that are *types*. For example, we can write the following in RDL:
+RDL is a lightweight system for adding types, type checking, and contracts to Ruby.  In RDL, *types* can be used to decorate methods:
 
 ```ruby
 require 'rdl'
@@ -74,9 +58,9 @@ type '(Fixnum, Fixnum) -> String'
 def m(x,y) ... end
 ```
 
-This indicates that `m` is that method that returns a `String` if given two `Fixnum` arguments. Again this contract is enforced at run-time: When `m` is called, RDL checks that `m` is given exactly two arguments and both are `Fixnums`, and that `m` returns an instance of `String`. RDL supports many more complex type annotations; see below for a complete discussion and examples. We should emphasize here that RDL types are enforced as contracts at method entry and exit. There is no static checking that the method body conforms to the types.
+This indicates that `m` returns a `String` if given two `Fixnum` arguments. When written as above, RDL enforces this type as a *contract* checked at run time: When `m` is called, RDL checks that `m` is given exactly two arguments and both are `Fixnums`, and that `m` returns an instance of `String`.
 
-The beta version of RDL also has an experimental mode in which method bodies can be *statically type checked* against their signatures. (This feature is only in the beta version of the RDL gem.) For example:
+RDL can also *statically type check* method bodies against their signatures. For example:
 
 ```ruby
 file.rb:
@@ -98,7 +82,9 @@ $ ruby file.rb
 
 Passing `typecheck: :now` to `type` checks the method body immediately or as soon as it is defined. Passing `typecheck: :call` to `type` statically type checks the method body whenever it is called. Passing `typecheck: sym` for some other symbol statically type checks the method body when `rdl_do_typecheck sym` is called.
 
-RDL contracts and types are stored in memory at run time, so it's also possible for programs to query them. RDL includes lots of contracts and types for the core and standard libraries. Since those methods are generally trustworthy, RDL doesn't actually enforce the contracts (since that would add overhead), but they are available to search and query. RDL includes a small script `rdl_query` to look up type information from the command line. Note you might need to put the argument in quotes depending on your shell.
+RDL supports many more complex type annotations; see below for a complete discussion and examples.
+
+RDL types are stored in memory at run time, so it's also possible for programs to query them. RDL includes lots of contracts and types for the core and standard libraries. Since those methods are generally trustworthy, RDL doesn't actually enforce the contracts (since that would add overhead), but they are available to search, query, and use during type checking. RDL includes a small script `rdl_query` to look up type information from the command line. Note you might need to put the argument in quotes depending on your shell.
 
 ```shell
 $ rdl_query String#include?            # print type for instance method of another class
@@ -122,7 +108,19 @@ $ irb
 > rdl_query '...' # as above
 ```
 
-Currently only type information is returned by `rdl_query` (and not other pre or postconditions).
+RDL also supports more general contracts, though these can only be enforced at run time and are not statically checked. These more general contracts take the form of *preconditions*, describing what a method assumes about its inputs, and *postconditions*, describing what a method guarantees about its outputs. For example:
+
+```ruby
+require 'rdl'
+
+pre { |x| x > 0 }
+post { |r,x| r > 0 }
+def sqrt(x)
+  # return the square root of x
+end
+```
+
+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`. Note that pre- and postconditions can't be searched for using `rdl_query`.
 
 # Using RDL
 
@@ -136,11 +134,11 @@ RDL currently supports Ruby 2.x. It may or may not work with other versions.
 
 ## Loading RDL
 
-Use `require 'rdl'` to load the RDL library. If you want to use the core and standard library type signatures that come with RDL, follow it with `require 'rdl_types'`.  This will load the types based on the current `RUBY_VERSION`. Currently RDL has types for the following versions of Ruby:
+Use `require 'rdl'` to load the RDL library. If you want to use the core and standard library type signatures that come with RDL, follow it with `require 'types/core'`.  This will load the types based on the current `RUBY_VERSION`. Currently RDL has types for the following versions of Ruby:
 
 * 2.x
 
-(Currently all these are assumed to have the same library type signatures, which may not be correct.)
+(Currently all 2.x versions are assumed to have the same library type signatures, which may not be correct.)
 
 ## Disabling RDL
 
@@ -164,13 +162,18 @@ to get the head version from github.
 
 In development and test mode, you will now have access to `rdl`, `types/core` from RDL, and extra type annotations for Rails and some related gems. In production mode, RDL will be disabled (by loading `rdl_disable`).
 
-Currently, rdl has types for the following versions of Rails:
+**Warning:** Rails support is currently extremely limited, not well tested, and generally needs more work...please send bug reports/pull requests/etc and we will fix things.
+
+Currently, RDL has types for the following versions of Rails:
 
 * Rails 5.x support - limited to the following:
-  * Automatically generates
-    * Models
-      * Type annotations for model column getters and setters
-      * `find_by` and `find_by!`
+  * Models
+    * Generates type annotations for model column getters and setters
+    * `find_by` and `find_by!`
+    * Generates types annotations for methods added by `belongs_to`, `has_one`, `has_many`, `has_and_belongs_to_many`.
+      * Note currently RDL doesn't do very precise type checking of relations
+  * Controllers
+    * `errors`
 
 ## Preconditions and Postconditions
 
@@ -559,6 +562,12 @@ type MyClass, :foo, '(a: Fixnum, b: String) { () -> %any } -> %any'
 ```
 Here `foo`, takes a hash where key `:a` is mapped to a `Fixnum` and key `:b` is mapped to a `String`. Similarly, `{'a'=>Fixnum, 2=>String}` types a hash where keys `'a'` and `2` are mapped to a `Fixnum` and `String`, respectively. Both syntaxes can be used to define hash types.
 
+RDL also allows a "rest" type in finite hashes (of course, they're not so finite if they use it!):
+```ruby
+type MyClass, :foo, '(a: Fixnum, b: String, **Float) -> %any'
+```
+In this method, `a` is a `Fixnum`, `b` is a `String`, and any number (zero or more) remaining keyword arguments can be passed where the values have type `Float`, e.g., a call `foo(a: 3, b: 'b', pi: 3.14)` is allowed.
+
 ## Type Casts
 
 Sometimes RDL does not have precise information about an object's type (this is most useful during static type checking). For these cases, RDL supports type casts of the form `o.type_cast(t)`. This call returns a new object that delegates all methods to `o` but that will be treated by RDL as if it had type `t`. If `force: true` is passed to `type_cast`, RDL will perform the cast without checking whether `o` is actually a member of the given type. For example, `x = "a".type_cast('nil', force: true)` will make RDL treat `x` as if it had type `nil`, even though it's a `String`.
@@ -577,23 +586,19 @@ Types can be prefixed with `!` to indicate the associated value is not `nil`. Fo
 
 # 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.
+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.
 
 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:
+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'
+[3] pry(main)> require 'types/core'
 [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  
+[5] pry(main)> def f; 'haha'; end
 [6] pry(main)> rdl_do_typecheck :later
 RDL::Typecheck::StaticTypeError:
 (string):2:3: error: got type `String' where return type `Fixnum' expected
@@ -639,7 +644,7 @@ 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.
+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 variable 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`:
 
@@ -656,7 +661,7 @@ end
 
 The `var_type` method may also be called as `var_type klass, :name, typ` to assign a type to an instance or class variable of class `klass`.
 
-As a short-hand, RDL defines methods `attr_accessor_type`, `attr_reader_type`, and `attr_writer_type` to behave like their corresponding non-`_type` analogs but  attribute types follow the attribute names. For example, `attr_accessor_type :f, 'Fixnum', :g, 'String'` is equivalent to:
+As a short-hand, RDL defines methods `attr_accessor_type`, `attr_reader_type`, and `attr_writer_type` to behave like their corresponding non-`_type` analogs but  assign types to the attributes. For example, `attr_accessor_type :f, 'Fixnum', :g, 'String'` is equivalent to:
 
 ```ruby
 var_type :@f, 'Fixnum'
@@ -694,16 +699,18 @@ var_type @g, 'Array<Fixnum or String>'
 @g = x          # uh oh
 ```
 
-When RDL encounters the assignment to `@g`, it retroactively changes `x` to have type `Array<Fixnum or String>`, which is incompatible with type `[1, String]`, so the last assignment signals an error.
+When RDL encounters the assignment to `@g`, it retroactively changes `x` to have type `Array<Fixnum or String>`, which is incompatible with type `[1, String]` of `@f`, so the assignment to `@g` signals an error.
 
 RDL uses the same approach for hashes: hash literals are treated as finite hashes. A finite hash `{k1=>v1, ..., kn=>vn}` can be used where `Hash<k1 or ... or kn, v1 or ... or vn>` is expected. And if a finite hash is used as a `Hash` (including invoking methods on the finite hash; this may change in the future), then it is retroactively converted to a `Hash`.
 
 ## 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.
+*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`.
 
+* *Case analysis by class.* If the guard of a `case` statement is a variable, and then `when` branches compare against classes, RDL refines the type of the guard to be those classes within the corresponding `when` branch. For example, in `case x when Fixnum ...(1)... when String ...(2)... end`, RDL will assume `x` is a `Fixnum` within `(1)` and a `String` within `(2)`.
+
 * *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.
@@ -714,16 +721,17 @@ RDL uses the same approach for hashes: hash literals are treated as finite hashe
 
 * *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.
-  * `lambda` has special semantics for `return`; this is not supported.
-  * Only simple block argument lists and `for` iteration variables are supported.
+  * `lambda` has special semantics for `return`; this is not supported. Stabby lambda is also not supported.
+  * Only simple `for` iteration variables are supported.
   * 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:
+RDL's static type checker makes some assumptions that should hold unless your Ruby code is doing something highly unusual. RDL assumes:
 
 * `Class#===` is not redefined
+* `Proc#call` is not redefined
 
 (More assumptions will be added here as they are added to RDL...)
 
@@ -739,6 +747,8 @@ RDL also includes a few other useful methods:
 
 * `rdl_query` prints information about types; see below for details.
 
+* `rdl_do_at(sym, &blk)` invokes `blk.call(sym)` when `rdl_do_typecheck(sym)` is called. Useful when type annotations need to be generated at some later time, e.g., because not all classes are loaded.
+
 # Queries
 
 As discussed above, RDL includes a small script, `rdl_query`, to look up type information. (Currently it does not support other pre- and postconditions.) The script takes a single argument, which should be a string. Note that when using the shell script, you may need to use quotes depending on your shell. Currently several queries are supported:
@@ -811,7 +821,7 @@ RDL supports the following configuration options:
 
 # Bibliography
 
-Here are some research papers we have written exploring contracts, types, and Ruby.
+Here are some research papers we have written exploring types, contracts, and Ruby.
 
 * Brianna M. Ren and Jeffrey S. Foster.
 [Just-in-Time Static Type Checking for Dynamic Languages](http://www.cs.umd.edu/~jfoster/papers/pldi16.pdf).
@@ -863,44 +873,6 @@ Copyright (c) 2014-2016, University of Maryland, College Park. All rights reserv
 * Alexander T. Yu
 * Milod Kazerounian
 
-# TODO List
-
-* How to check whether initialize? is user-defined? method_defined? always
-  returns true, meaning wrapping isn't fully working with initialize.
-
-* Currently if a NominalType name is expressed differently, e.g., A
-  vs. EnclosingClass::A, the types will be different when compared
-  with ==.
-
-* Macros, %bool should really be %any
-
-* Method types that are parametric themselves (not just ones that use
-  enclosing class parameters)
-
-* Rails types
-
-* Deferred contracts on new (watch for class addition)
-
-* DSL contracts
-
-* double-splat arguments, which bind to an arbitrary set of keywords
-
-* included versus extended modules, e.g., Kernel is included in Object, so its
-  class methods become Object's instance methods
-
-* Better story for different types for different Ruby versions
-
-* Better query facility (more kinds of searches). Contract queries?
-
-* Write documentation on: Raw Contracts and Types, RDL Configuration, Code Overview
-
-* Structural type queries, allow name to be unknown; same with finite hash keys,
-  same with generic base types?
-
-* Allow ... in named args list in queries
-
-* Queries, include more regexp operators aside from . and ...
-
-* Queries, allow regexp in class and method names; suggested by Andreas Adamcik, Vienna
+# Discussion group
 
-* Tag for private methods
+[RDL Users](https://groups.google.com/forum/#!forum/rdl-users)

data/lib/rdl/boot.rb

@@ -46,6 +46,9 @@ $__rdl_to_wrap = Set.new
 $__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 = []
 
@@ -122,6 +125,7 @@ $__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,

data/lib/rdl/boot_rails.rb

@@ -7,7 +7,9 @@ if Rails.env.development? || Rails.env.test?
   Dir[File.dirname(__FILE__) + "/../types/rails-#{dir}/**/*.rb"].each { |f| require f }
 elsif Rails.env.production?
   require 'rdl_disable'
-  def (ActionController::Base).params_type(typs); end
+  class ActionController::Base
+    def self.params_type(typs); end
+  end
 else
   raise RuntimeError, "Don't know what to do in Rails environment #{Rails.env}"
 end

data/lib/rdl/contracts/flat.rb

@@ -9,8 +9,7 @@ module RDL::Contract
 
     def check(slf, *v, &blk)
       $__rdl_contract_switch.off {
-        if (@pred &&
-            ((@pred.arity < 0) ? (@pred.arity.abs - 1) <= v.size : @pred.arity == v.size)) then
+        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)
             raise ContractError,

data/lib/rdl/typecheck.rb

@@ -2,7 +2,7 @@ module RDL::Typecheck
 
   class StaticTypeError < StandardError; end
 
-  @@empty_hash_type = RDL::Type::FiniteHashType.new(Hash.new)
+  @@empty_hash_type = RDL::Type::FiniteHashType.new(Hash.new, nil)
   @@asgn_to_var = { lvasgn: :lvar, ivasgn: :ivar, cvasgn: :cvar, gvasgn: :gvar }
 
   # Create mapping from file/line numbers to the def that appears at that location
@@ -208,7 +208,6 @@ module RDL::Typecheck
     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)
         # to_class gets the class object itself, so remove singleton marker to get class rather than singleton class
         self_type = RDL::Type::SingletonType.new(RDL::Util.to_class(RDL::Util.remove_singleton_marker(klass)))
@@ -217,10 +216,7 @@ module RDL::Typecheck
       end
       inst = {self: self_type}
       type = type.instantiate inst
-      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
-      targs = args.children.map { |arg| arg.children[0] }.zip(type.args).to_h
+      _, targs = args_hash({}, Env.new, type, args, ast, 'method')
       targs[:self] = self_type
       scope = { tret: type.ret, tblock: type.block, captured: Hash.new, context_types: context_types }
       begin
@@ -236,6 +232,79 @@ module RDL::Typecheck
     $__rdl_info.set(klass, meth, :typechecked, true)
   end
 
+  # [+ scope +] is used to typecheck default values for optional arguments
+  # [+ env +] is used to typecheck default values for optional arguments
+  # [+ type +] is a MethodType
+  # [+ args +] is an `args` node from the AST
+  # [+ ast +] is where to report an error if `args` is empty
+  # [+ kind +] is either `'method'` or `'block'`, and is only used for printing error messages
+  # Returns a Hash<Symbol, Type> mapping formal argument names to their types
+  def self.args_hash(scope, env, type, args, ast, kind)
+    targs = Hash.new
+    tpos = 0 # position in type.args
+    kw_args_matched = []
+    kw_rest_matched = false
+    args.children.each { |arg|
+      error :type_args_fewer, [kind, kind], arg if tpos >= type.args.length && arg.type != :blockarg  # blocks could be called with yield
+      targ = type.args[tpos]
+      if arg.type == :arg
+        error :type_arg_kind_mismatch, [kind, 'optional', 'required'], arg if targ.optional?
+        error :type_arg_kind_mismatch, [kind, 'vararg', 'required'], arg if targ.vararg?
+        targs[arg.children[0]] = targ
+        tpos += 1
+      elsif arg.type == :optarg
+        error :type_arg_kind_mismatch, [kind, 'vararg', 'optional'], arg if targ.vararg?
+        error :type_arg_kind_mismatch, [kind, 'required', 'optional'], arg if !targ.optional?
+        env, default_type = tc(scope, env, arg.children[1])
+        error :optional_default_type, [default_type, targ.type], arg.children[1] unless default_type <= targ.type
+        targs[arg.children[0]] = targ.type
+        tpos += 1
+      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)
+        tpos += 1
+      elsif arg.type == :kwarg
+        error :type_args_no_kws, [kind], arg unless targ.is_a?(RDL::Type::FiniteHashType)
+        kw = arg.children[0]
+        error :type_args_no_kw, [kind, kw], arg unless targ.elts.has_key? kw
+        tkw = targ.elts[kw]
+        error :type_args_kw_mismatch, [kind, 'optional', kw, 'required'], arg if tkw.is_a? RDL::Type::OptionalType
+        kw_args_matched << kw
+        targs[kw] = tkw
+      elsif arg.type == :kwoptarg
+        error :type_args_no_kws, [kind], arg unless targ.is_a?(RDL::Type::FiniteHashType)
+        kw = arg.children[0]
+        error :type_args_no_kw, [kind, kw], arg unless targ.elts.has_key? kw
+        tkw = targ.elts[kw]
+        error :type_args_kw_mismatch, [kind, 'required', kw, 'optional'], arg if !tkw.is_a?(RDL::Type::OptionalType)
+        env, default_type = tc(scope, env, arg.children[1])
+        error :optional_default_kw_type, [kw, default_type, tkw.type], arg.children[1] unless default_type <= tkw.type
+        kw_args_matched << kw
+        targs[kw] = tkw.type
+      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)
+        kw_rest_matched = true
+      elsif arg.type == :blockarg
+        error :type_arg_block, [kind, kind], arg unless type.block
+        targs[arg.children[0]] = type.block
+        # Note no check that if type.block then method expects block, because blocks can be called with yield
+      else
+        error :generic_error, ["Don't know what to do with actual argument of type #{arg.type}"], arg
+      end
+    }
+    if (tpos == type.args.length - 1) && type.args[tpos].is_a?(RDL::Type::FiniteHashType)
+      rest = type.args[tpos].elts.keys - kw_args_matched
+      error :type_args_kw_more, [kind, rest.map { |s| s.to_s }.join(", "), kind], ast unless rest.empty?
+      error :type_args_kw_rest, [kind], ast unless kw_rest_matched || type.args[tpos].rest.nil?
+    else
+      error :type_args_more, [kind, kind], (if args.children.empty? then ast else args end) if type.args.length != tpos
+    end
+    return [env, targs]
+  end
+
   # The actual type checking logic.
   # [+ scope +] tracks flow-insensitive information about the current scope, excluding local variables
   # [+ env +] is the (local variable) Env
@@ -339,7 +408,7 @@ module RDL::Typecheck
       if is_fh
         # keys are all symbols
         fh = tlefts.map { |t| t.val }.zip(trights).to_h
-        [envi, RDL::Type::FiniteHashType.new(fh)]
+        [envi, RDL::Type::FiniteHashType.new(fh, nil)]
       else
         tleft = RDL::Type::UnionType.new(*tlefts)
         tright = RDL::Type::UnionType.new(*trights)
@@ -507,6 +576,12 @@ module RDL::Typecheck
             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
@@ -918,7 +993,7 @@ RUBY
   # [+ trecvs +] is the type of the recevier
   # [+ meth +] is a symbol with the method name
   # [+ tactuals +] are the actual arguments
-  # [+ block +] is a pair of expressions [block-args, block-body], from the block AST node
+  # [+ block +] is a pair of expressions [block-args, block-body], from the block AST node OR [block-type, block-arg-AST-node]
   # [+ e +] is the expression at which location to report an error
   def self.tc_send(scope, env, trecvs, meth, tactuals, block, e)
     scope[:exn] = Env.join(e, scope[:exn], env) if scope.has_key? :exn # assume this call might raise an exception
@@ -947,6 +1022,16 @@ RUBY
         error :no_singleton_method_type, [trecv.val, meth], e unless ts
         inst = {self: trecv}
         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
+        if env[:self].is_a?(RDL::Type::NominalType)
+          klass = env[:self].klass
+        else # SingletonType(class)
+          klass = env[:self].val
+        end
+        ts = lookup(scope, klass.to_s, trecv.val, e)
+        error :no_type_for_symbol, [trecv.val.inspect], e if ts.nil?
+        return ts
       else
         klass = trecv.val.class.to_s
         ts = lookup(scope, klass, meth, e)
@@ -970,6 +1055,14 @@ RUBY
       tmeth_inter = ts.map { |t| t.instantiate(inst) }
     when RDL::Type::VarType
       error :recv_var_type, [trecv], e
+    when RDL::Type::MethodType
+      if meth == :call
+        # Special case - invokes the Proc
+        tmeth_inter = [trecv]
+      else
+        # treat as Proc
+        tc_send_one_recv(scope, env, $__rdl_proc_type, meth, tactuals, block, e)
+      end
     else
       raise RuntimeError, "receiver type #{trecv} not supported yet"
     end
@@ -1006,12 +1099,14 @@ Actual arg type#{tactuals.size > 1 ? "s" : ""}:
       (#{tactuals.map { |ti| ti.to_s }.join(', ')}) #{if block then '{ block }' end}
 RUBY
       msg.chomp! # remove trailing newline
-      name = if (trecv.is_a? RDL::Type::SingletonType) && (trecv.val.is_a? Class) && (meth == :new) then
+      name = if trecv.is_a?(RDL::Type::SingletonType) && trecv.val.is_a?(Class) && (meth == :new) then
         :initialize
       elsif trecv.is_a? RDL::Type::SingletonType
         trecv.val.class.to_s
-      elsif (trecv.is_a? RDL::Type::NominalType) || (trecv.is_a? RDL::Type::GenericType)
+      elsif trecv.is_a?(RDL::Type::NominalType) || trecv.is_a?(RDL::Type::GenericType)
         trecv.to_s
+      elsif trecv.is_a?(RDL::Type::MethodType)
+        'Proc'
       else
         raise RuntimeError, "impossible to get type #{trecv}"
       end
@@ -1079,27 +1174,28 @@ RUBY
   end
 
   # [+ tblock +] is the type of the block (a MethodType)
-  # [+ block +] is a pair [block-args, block-body] from the block AST node
+  # [+ block +] is a pair [block-args, block-body] from the block AST node OR [block-type, block-arg-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, 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
-    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? || RDL::Type::Type.leq(body_type, tblock.ret, inst, false)
-      #
-    }
+    if block[0].is_a? RDL::Type::MethodType
+      error :bad_block_arg_type, [block[0], tblock], block[1] unless block[0] <= tblock
+    elsif block[0].is_a?(RDL::Type::NominalType) && block[0].name == 'Proc'
+      error :proc_block_arg_type, [tblock], block[1]
+    else # must be [block-args, block-body]
+      args, body = block
+      env, targs = args_hash(scope, env, tblock, args, block, 'block')
+      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
+        error :bad_return_type, [body_type, tblock.ret], body unless body.nil? || RDL::Type::Type.leq(body_type, tblock.ret, inst, false)
+        #
+      }
+    end
   end
 
   # [+ klass +] is a string containing the class name
@@ -1173,7 +1269,6 @@ type_error_messages = {
   masgn_bad_lhs: "no corresponding right-hand side elemnt for left-hand side assignee",
   kw_not_allowed: "can't use `%s' in current scope",
   kw_arg_not_allowed: "argument to `%s' not allowed in current scope",
-  arg_count_mismatch: "`%s' signature expects %d arguments, actual `%s' has %d arguments",
   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",
@@ -1187,7 +1282,23 @@ type_error_messages = {
   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",
+  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)