rdl 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: aabf7af1d05594fdd962964b90285fa322cc9aef
-  data.tar.gz: 435dff6920f147343d71bf459fa8de1462358195
+SHA256:
+  metadata.gz: cd1da46a0ca86e95d211710bd2fbf149d299a4e85d481970afbff765ab9150f1
+  data.tar.gz: eb03a0a773a98e85eef56e0fdcc7b266eb35dd960470076d5db6de1259fdb9c4
 SHA512:
-  metadata.gz: 9ae6a8193a9589662d98b35ab30eec6836dcbd123317e7e820916728a8686b0b3e1d914f433d91a44c904468d763eac316bab00886441675246fc46e8ce410e3
-  data.tar.gz: b6503f4c82c45555249c85e08c4ae9d10dc287f62462c22cf36dfaa48d63d6a4151b27b747871024fc4b398ea280bb3584355a08dc0b097f11a0c346f08fc9fb
+  metadata.gz: 9ea8b806ceee543905a3c1fbdc9c68ec9eb599b793ef3c24d902c3bca019b7321cc755f5cfca510766c222791426341307228faeea886e1d889eedd6ed1a9150
+  data.tar.gz: 4c1ec45edbff7d790362f97de394eb7d14d5eb7a3d0bb0ff0ae86f637e40f3ae364a0d9fdba53dc931c0bcd3af6ac120374cf8aa3ebef1fff4f374fe02223a56

data/.gitignore

@@ -26,6 +26,7 @@
 *.rar\
 *.tar\
 *.zip\
+*.gem\
 \'a0\
 # Logs and databases #\
 ######################\

data/.travis.yml

@@ -2,12 +2,7 @@ language: ruby
 gemfile:
   - gemfiles/Gemfile.travis
 rvm:
-  - 2.1.0
   - 2.1.1
-  - 2.1.2
-  - 2.1.3
-  - 2.1.4
-  - 2.1.5
   - 2.1.6
   - 2.1.7
   - 2.1.8
@@ -25,7 +20,13 @@ rvm:
   - 2.3.4
   - 2.4.0
   - 2.4.1
-sudo: false
+  - 2.4.2
+  - 2.4.3
+  - 2.4.4
+  - 2.4.5
+  - 2.5.5
+  - 2.6.2
+  - 2.6.3
 notifications:
   email:
     recipients:

data/CHANGES.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [2.2.0] - 2019-06-09
+
+### Fixed
+- Dynamic type checking of initialize method
+- Bug with handling constants of certain types
+- Broken rdl_attr_* methods
+- Bug handling optional annotated/dependent types
+- Add RDLAnnotate to rdl_disable
+- Type checking of Object class singleton methods
+- #52 Kernel.raise annotation
+- #42 use grandparent type information for methods
+- #43 allow fully qualified calls
+- #45 handle local constants
+- #62 allow more method names in structural types
+- #34 clean up discussion of how type checking works in README
+- Reordered list of RDL.* methods in README
+- Remove (most) ordering dependencies among test cases
+- Undefined identified issue for Rails assocation types
+- Type check expressions within casts
+- Fix to `var_type` method when called from outside class
+- Add `RDL.query` support for nested classes, e.g., `RDL.query "ActiveRecord::Base#id`
+
+### Added
+- Support for type-level computations, including new annotations with
+  type-level computations for Array, Hash, String, Integer, Float, and
+  database query libraries
+- Dynamic type
+- `RDL.reset` method
+
 ## [2.1.0] - 2017-06-14
 
 ### Fixed

data/README.md

@@ -1,5 +1,4 @@
-[![Gem Version](https://badge.fury.io/rb/rdl.svg)](https://badge.fury.io/rb/rdl) [![Build Status](https://travis-ci.org/plum-umd/rdl.svg?branch=master)](https://travis-ci.org/plum-umd/rdl)
-
+[![Gem Version](https://badge.fury.io/rb/rdl.svg)](https://badge.fury.io/rb/rdl) [![Build Status](https://travis-ci.org/tupl-tufts/rdl.svg?branch=master)](https://travis-ci.org/tupl-tufts/rdl)
 
 # Table of Contents
 
@@ -16,6 +15,7 @@
   * [Nominal Types](#nominal-types)
   * [Nil Type](#nil-type)
   * [Top Type (%any)](#top-type-any)
+  * [Dynamic Type (%dyn)](#dynamic-type-dyn)
   * [Union Types](#union-types)
   * [Intersection Types](#intersection-types)
   * [Optional Argument Types](#optional-argument-types)
@@ -40,6 +40,7 @@
   * [Tuples, Finite Hashes, and Subtyping](#tuples-finite-hashes-and-subtyping)
   * [Other Features and Limitations](#other-features-and-limitations)
   * [Assumptions](#assumptions)
+* [Type-Level Computations](#type-level-computations)
 * [RDL Method Reference](#rdl-method-reference)
 * [Performance](#performance)
 * [Queries](#queries)
@@ -70,10 +71,12 @@ file.rb:
   require 'rdl'
   extend RDL::Annotate
 
-  type '(Integer) -> Integer', typecheck: :now
+  type '(Integer) -> Integer', typecheck: :label
   def id(x)
     "forty-two"
   end
+
+  RDL.do_typecheck :label
 ```
 
 ```
@@ -84,13 +87,15 @@ $ ruby file.rb
 .../file.rb:6:   ^~~~~~~~~~~
 ```
 
-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.
+Passing `typecheck: sym` for some other symbol statically type checks the method body when `RDL.do_typecheck sym` is called. Passing `typecheck: :call` to `type` statically type checks the method body whenever it is called.
+
+Note that RDL only type checks the bodies of methods with type signatures. Methods without type signatues, or code that is not in method bodies, is not checked.
 
 The `type` method can also be called with the class and method to be annotated, and it can also be invoked as `RDL.type` in case `extend RDL::Annotate` would cause namespace issues:
 
 ```
-  type :A, :id, '(Integer) -> Integer', typecheck: :now # Add a type annotation for A#id.
-  RDL.type :A, :id, '(Integer) -> Integer', typecheck: :now # Note class and method name required when calling like this
+  type :A, :id, '(Integer) -> Integer', typecheck: :label # Add a type annotation for A#id.
+  RDL.type :A, :id, '(Integer) -> Integer', typecheck: :label # Note class and method name required when calling like this
 ```
 
 RDL tries to follow the philosophy that you get what you pay for. Methods with type annotations can be checked dynamically or statically; methods without type annotations are unaffected by RDL. See the [performance](#performance) discussion for more detail.
@@ -136,11 +141,13 @@ 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`. The `pre` and `post` methods can also be called as `RDL.pre` and `RDL.post`, as long as they are also given class and method arguments, similarly to `type`. Note that pre- and postconditions can't be searched for using `RDL.query`.
 
+Note: RDL is a research project from the [Tufts University Computer Science Department](https://www.cs.tufts.edu) and the [University of Maryland, College Park Computer Science Department](https://www.cs.umd.edu). If you are looking for an industrial strength Ruby type system, check out Stripe’s [Sorbet](https://sorbet.org) system.
+
 # Using RDL
 
 ## Supported versions of Ruby
 
-RDL currently supports Ruby 2.x. It may or may not work with other versions.
+RDL currently supports Ruby 2.x except 2.1.1-2.1.6. RDL may or may not work with other versions.
 
 ## Installing RDL
 
@@ -249,6 +256,14 @@ type Object, :=~, '(%any) -> nil'
 ```
 We call this the "top" type because it is the top of the subclassing hierarchy RDL uses. Note that `%any` is more general than `Object`, because not all classes inherit from `Object`, e.g., `BasicObject` does not.
 
+## Dynamic Type (%dyn)
+
+RDL has the dynamic type `%dyn` that is the subtype and supertype of any type.
+```ruby
+type Example, :method, '(%dyn) -> %dyn'
+```
+This is useful for typed portions of a Ruby program that interact with untyped portions. RDL allows setting a [configuration option](#configuration) `assume_dyn_type` to `true` so that any method that is missing a type will be assumed to take and return the dynamic type. By default, this option is set to `false`.
+
 ## Union Types
 
 Many Ruby methods can take several different types of arguments or return different types of results. The union operator `or` can be used to indicate a position where multiple types are possible.
@@ -561,6 +576,12 @@ type MyClass, :foo, '(a: Integer, b: String) { () -> %any } -> %any'
 ```
 Here `foo`, takes a hash where key `:a` is mapped to an `Integer` and key `:b` is mapped to a `String`. Similarly, `{'a'=>Integer, 2=>String}` types a hash where keys `'a'` and `2` are mapped to `Integer` and `String`, respectively. Both syntaxes can be used to define hash types.
 
+Value types can also be declared as optional, indicating that the key/value pair is an optional part of the hash:
+```ruby
+type MyClass, :foo, '(a: Integer, b: ?String) { () -> %any } -> %any'
+```
+With this type, `foo` takes a hash where key `:a` is mapped to an `Integer`, and furthermore the hash may or may not include a key `:b` that is mapped to a `String`. 
+
 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: Integer, b: String, **Float) -> %any'
@@ -595,11 +616,9 @@ type :initialize, '(String, Fixnum) -> self'
 
 # 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.
+As mentioned in the introduction, calling `type` with `typecheck: sym` statically type checks the body of the annotated method body against the given signature when `RDL.do_typecheck sym` is called. Note that at this call, all methods whose `type` call is labeled with `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.
+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. Finally, `type` can be called with `typecheck: :now` to check the method immediately after it is defined. This is probably only useful for demos.
 
 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:
 
@@ -746,6 +765,36 @@ RDL's static type checker makes some assumptions that should hold unless your Ru
 
 (More assumptions will be added here as they are added to RDL...)
 
+# Type-Level Computations
+
+RDL includes support for type-level computations: embedding Ruby code *within* a method's type signature. Using these type-level computations, we can write type signatures that can check more expressive properties, such as the correctness of column names and types in a database query. We have found that type-level computations significantly reduce the need for manually inserted type casts. Below we will cover the basics of using type-level computations. For a closer look, check out our [paper](https://www.cs.tufts.edu/~jfoster/papers/pldi19.pdf) on the same topic.
+
+We use type-level computations only in type signatures for methods which themselves are *not* type checked. Thus, our primary focus is on applying them to library methods. We add a computation to a type by writing Ruby code, delimited by double backticks \`\`...\`\`, in place of a type within a method's signature. This Ruby code may refer to two special variables: `trec`, which names the RDL type of the receiver for a given method call, and `targs`, which names an array of RDL types of the arguments for a given method call. The code must itself evaluate to a type.
+
+As an example, we will write a type-level computation for the `Integer#+` method. Normaly, this method would have the simple RDL type `type '(Integer) -> Integer'` (for the case that it takes another `Integer`). Using type level computations, we can write the following more precise type:
+
+```ruby
+type '(Integer) -> ``if trec.is_a?(RDL::Type::SingletonType) && targs[0].is_a?(RDL::Type::SingletonType) then RDL::Type::SingletonType.new(trec.val+targs[0].val) else RDL::Type::NominalType.new(Integer) end``'
+```
+
+Now, in place of a simple return type, we have written some Ruby code. This code checks if both the receiver (`trec`) and argument (`targs[0]`) have a singleton type. If so, in the first arm of the branch we compute a new singleton type containing the sum of the receiver and argument. Otherwise, we fall back on returning the nominal type `Integer`. With this signature, RDL can determine the expression `1+2` has the type `3`, rather than the less precise type `Integer`.
+
+We also provide a way of binding variable names to argument types, to avoid using the variable `targs`. For example, for the type signature above, we can give the argument type the name `t`, which we then refer to in the type-level computation:
+
+```ruby
+type '(Integer) -> ``if trec.is_a?(RDL::Type::SingletonType) && t.is_a?(RDL::Type::SingletonType) then RDL::Type::SingletonType.new(trec.val+t.val) else RDL::Type::NominalType.new(Integer) end``'
+```
+
+We have written type-level computations for methods from the Integer, Float, Array, Hash, and String core libraries, which you can find  in the `/lib/types/core/` directory. We have also written them for a number of database query methods from both the [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord) and [Sequel](https://github.com/jeremyevans/sequel) DSLs. They can be found in `comp_types.rb` file in the `/lib/types/rails/active_record` and `/lib/types/sequel` directories, respectively. These type-level computations for the database query methods depend on RDL pre-processing the schema of the database before type checking any user code. RDL provides helper methods to process the database schema:
+
+```ruby
+RDL.load_sequel_schema(DATABASE) # `DATABASE` is the Sequel Database object
+
+RDL.load_rails_schema # Automatically triggered if RDL is loaded in a Rails environment. If you want to use ActiveRecord without Rails, you need to call this method
+```
+
+Because type-level computations are used for methods which themselves are not type checked, we include an optional configuration for inserting dynamic checks that ensure that these methods return values of the type expected by their type-level computation. Additionally, because type-level computations can refer to mutable state, we include a second configuration for re-running type-level computations at runtime to ensure that they evaluate to the same value they did at type checking time. Both of these configurations are by default turned off. See the [Configuration](#configuration) section for information on turning them on.
+
 # RDL Method Reference
 
 The following methods are available in `RDL::Annotate`.
@@ -768,25 +817,28 @@ The following methods are available in `RDL::Annotate`.
 
 The methods above can also be accessed as `rdl_method` after `extend RDL::RDLAnnotate`. They can also be accessed as `RDL.method`, but when doing so, however, the `klass` and `meth` arguments are not optional and must be specified. The `RDL` module also includes several other useful methods:
 
-* `RDL.type_alias '%name', typ` - indicates that if `%name` appears in a type annotations, it should be expanded to `typ`.
+* `RDL.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.
 
-* `RDL.nowrap [klass]`, 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 `klass`. 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. If `klass` is omitted it's assumed to be `self`.
+* `RDL.deinsantiate!(var)` - remove `var`'s instantiation.
 
 * `RDL.do_typecheck(sym)` statically type checks all methods whose type annotations include argument `typecheck: sym`.
 
-* `RDL.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.
+* `RDL.insantiate!(var, typ1, ...)` - `var` must have a generic type. Instantiates the type of `x` with type parameters `typ1`, ...
 
 * `RDL.note_type e` - evaluates `e` and returns it at run time. During static type checking, prints out the type of `e`.
 
+* `RDL.nowrap [klass]`, 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 `klass`. 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. If `klass` is omitted it's assumed to be `self`.
+
+* `RDL.query` prints information about types; see below for details.
+
 * `RDL.remove_type klass, meth` removes the type annotation for meth in klass. Fails if meth does not have a type annotation.
 
-* `RDL.insantiate!(var, typ1, ...)` - `var` must have a generic type. Instantiates the type of `x` with type parameters `typ1`, ...
+* `RDL.reset` resets all global state stored internally inside RDL back to their original settings. Note: this is really only for internal RDL testing, as it doesn't completely undo RDL's effect (e.g., wrapped methods will be broken by a reset).
 
-* `RDL.deinsantiate!(var)` - remove `var`'s instantiation.
+* `RDL.type_alias '%name', typ` - indicates that if `%name` appears in a type annotations, it should be expanded to `typ`.
 
 * `RDL.type_cast(e, typ, force: false)` - evaluate `e` and return it at run time. During dynamic contract checking, the returned object will have `typ` associated with it. If `force` is `false`, will also check that `e`'s run-time type is compatible with `typ`. If `force` is true then `typ` will be applied regardless of `e`'s type. During static type checking, the type checker will treat the object returned by `type_cast` has having type `typ`.
 
-* `RDL.query` prints information about types; see below for details.
 
 
 # Performance
@@ -876,51 +928,65 @@ RDL supports the following configuration options:
 * `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`.
+* `config.use_comp_types` - when true, RDL makes use of types with type-level computations. When false, RDL ignores such types. By default set to true.
+* `config.check_comp_types` - when true, RDL inserts dynamic checks which ensure that methods with type-level computations will return the expected type. False by default.
+* `config.rerun_comp_types` - when true, RDL inserts dynamic checks which rerun type-level computations at method call sites, ensuring that they evaluate to the same type they did at type checking time.  False by default.
+
 
 # Bibliography
 
 Here are some research papers we have written exploring types, contracts, and Ruby.
 
+* Milod Kazerounian, Sankha Narayan Guria, Niki Vazou, Jeffrey S. Foster, and David Van Horn.
+[Type-Level Computations for Ruby Libraries](https://www.cs.tufts.edu/~jfoster/papers/pldi19.pdf).
+In ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Phoenix, AZ, June 2019.
+
 * 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).
+[Just-in-Time Static Type Checking for Dynamic Languages](http://www.cs.tufts.edu/~jfoster/papers/pldi16.pdf).
 In ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Santa Barbara, CA, June 2016.
 
 * T. Stephen Strickland, Brianna Ren, and Jeffrey S. Foster.
-[Contracts for Domain-Specific Languages in Ruby](http://www.cs.umd.edu/~jfoster/papers/dls12.pdf).
+[Contracts for Domain-Specific Languages in Ruby](http://www.cs.tufts.edu/~jfoster/papers/dls12.pdf).
 In Dynamic Languages Symposium (DLS), Portland, OR, October 2014.
 
 * Brianna M. Ren, John Toman, T. Stephen Strickland, and Jeffrey S. Foster.
-[The Ruby Type Checker](http://www.cs.umd.edu/~jfoster/papers/oops13.pdf).
+[The Ruby Type Checker](http://www.cs.tufts.edu/~jfoster/papers/oops13.pdf).
 In Object-Oriented Program Languages and Systems (OOPS) Track at ACM Symposium on Applied Computing, pages 1565–1572, Coimbra, Portugal, March 2013.
 
 * Jong-hoon (David) An, Avik Chaudhuri, Jeffrey S. Foster, and Michael Hicks.
-[Dynamic Inference of Static Types for Ruby](http://www.cs.umd.edu/~jfoster/papers/popl11.pdf).
+[Dynamic Inference of Static Types for Ruby](http://www.cs.tufts.edu/~jfoster/papers/popl11.pdf).
 In ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), pages 459–472, Austin, TX, USA, January 2011.
 
 * Jong-hoon (David) An.
-[Dynamic Inference of Static Types for Ruby](http://www.cs.umd.edu/~jfoster/papers/thesis-an.pdf).
+[Dynamic Inference of Static Types for Ruby](http://www.cs.tufts.edu/~jfoster/papers/thesis-an.pdf).
 MS thesis, University of Maryland, College Park, 2010.
 
 * Michael Furr.
-[Combining Static and Dynamic Typing in Ruby](https://www.cs.umd.edu/~jfoster/papers/thesis-furr.pdf).
+[Combining Static and Dynamic Typing in Ruby](https://www.cs.tufts.edu/~jfoster/papers/thesis-furr.pdf).
 PhD thesis, University of Maryland, College Park, 2009.
 
 * Michael Furr, Jong-hoon (David) An, Jeffrey S. Foster, and Michael Hicks.
-[The Ruby Intermediate Langauge](http://www.cs.umd.edu/~jfoster/papers/dls09-ril.pdf).
+[The Ruby Intermediate Langauge](http://www.cs.tufts.edu/~jfoster/papers/dls09-ril.pdf).
 In Dynamic Languages Symposium (DLS), pages 89–98, Orlando, Florida, October 2009.
 
 * Michael Furr, Jong-hoon (David) An, and Jeffrey S. Foster.
-[Profile-Guided Static Typing for Dynamic Scripting Languages](http://www.cs.umd.edu/~jfoster/papers/oopsla09.pdf).
+[Profile-Guided Static Typing for Dynamic Scripting Languages](http://www.cs.tufts.edu/~jfoster/papers/oopsla09.pdf).
 In ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA), pages 283–300, Orlando, Floria, October 2009. Best student paper award.
 
 * Michael Furr, Jong-hoon (David) An, Jeffrey S. Foster, and Michael Hicks.
-[Static Type Inference for Ruby](http://www.cs.umd.edu/~jfoster/papers/oops09.pdf).
+[Static Type Inference for Ruby](http://www.cs.tufts.edu/~jfoster/papers/oops09.pdf).
 In Object-Oriented Program Languages and Systems (OOPS) Track at ACM Symposium on Applied Computing (SAC), pages 1859–1866, Honolulu, Hawaii, March 2009.
 
 # Copyright
 
 Copyright (c) 2014-2017, University of Maryland, College Park. All rights reserved.
 
+# Contributing
+
+Contributions are welcome! If you submit any pull requests, please
+submit them against the `dev` branch. We keep the `master` branch so
+it matches the latest gem version.
+
 # Authors
 
 * [Jeffrey S. Foster](http://www.cs.umd.edu/~jfoster/)
@@ -928,10 +994,12 @@ Copyright (c) 2014-2017, University of Maryland, College Park. All rights reserv
 * [T. Stephen Strickland](https://www.cs.umd.edu/~sstrickl/)
 * Alexander T. Yu
 * Milod Kazerounian
+* [Sankha Narayan Guria](https://sankhs.com/)
 
 # Contributors
 
 * [Joel Holdbrooks](https://github.com/noprompt)
+* [Paul Tarjan](https://github.com/ptarjan)
 
 # Discussion group
 

data/lib/rdl/boot.rb

@@ -13,6 +13,8 @@ end
 require 'rdl/info.rb'
 
 module RDL::Globals
+  FIXBIG_VERSIONS = ['>= 2.0.0', '< 2.4.0']
+
   # Method/variable info table with kinds:
   # For methods
   #   :pre to array of precondition contracts
@@ -52,6 +54,18 @@ module RDL::Globals
 
   # List of contracts that should be applied to the next method definition
   @deferred = []
+
+  # List of method types that have a dependent type. Used to type check type-level code.
+  @dep_types = []
+
+  ## Hash mapping node object IDs (integers) to a list [tmeth, tmeth_old, tmeth_res, self_klass, trecv_old, targs_old], where: tmeth is a MethodType that is fully evaluated (i.e., no ComputedTypes) *and instantiated*, tmeth_old is the unevaluated method type (i.e., with ComputedTypes), tmeth_res is the result of evaluating tmeth_old *but not instantiating it*, self_klass is the class where the MethodType is defined, trecv_old was the receiver type used to evaluate tmeth_old, and targs_old is an Array of the argument types used to evaluate tmeth_old.
+  @comp_type_map = {}
+
+  # Map from ActiveRecord table names (symbols) to their schema types, which should be a Table type
+  @ar_db_schema = {}
+
+  # Map from Sequel table names (symbols) to their schema types, which should be a Table type
+  @seq_db_schema = {}
 end
 
 class << RDL::Globals # add accessors and readers for module variables
@@ -63,6 +77,10 @@ class << RDL::Globals # add accessors and readers for module variables
   attr_accessor :to_typecheck
   attr_accessor :to_do_at
   attr_accessor :deferred
+  attr_accessor :dep_types
+  attr_accessor :comp_type_map
+  attr_accessor :ar_db_schema
+  attr_accessor :seq_db_schema
 end
 
 # Create switches to control whether wrapping happens and whether
@@ -81,15 +99,19 @@ end
 
 require 'rdl/types/type.rb'
 require 'rdl/types/annotated_arg.rb'
+require 'rdl/types/bound_arg.rb'
 require 'rdl/types/bot.rb'
+require 'rdl/types/computed.rb'
 require 'rdl/types/dependent_arg.rb'
 require 'rdl/types/dots_query.rb'
+require 'rdl/types/dynamic.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/ast_node.rb'
 require 'rdl/types/nominal.rb'
 require	'rdl/types/non_null.rb'
 require 'rdl/types/optional.rb'
@@ -102,6 +124,7 @@ require 'rdl/types/union.rb'
 require 'rdl/types/var.rb'
 require	'rdl/types/vararg.rb'
 require 'rdl/types/wild_query.rb'
+require	'rdl/types/string.rb'
 
 require 'rdl/contracts/contract.rb'
 require 'rdl/contracts/and.rb'
@@ -115,50 +138,68 @@ require 'rdl/query.rb'
 require 'rdl/typecheck.rb'
 #require_relative 'rdl/stats.rb'
 
-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
+
+module RDL
+  def self.reset
+    RDL::Globals.module_eval {
+      @info = RDL::Info.new
+      @wrapped_calls = Hash.new 0
+      @type_params = Hash.new
+      @aliases = Hash.new
+      @to_wrap = Set.new
+      @to_typecheck = Hash.new
+      @to_typecheck[:now] = Set.new
+      @to_do_at = Hash.new
+      @ar_db_schema = Hash.new
+      @seq_db_schema = Hash.new
+      @deferred = []
+
+      @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[:dyn] = RDL::Type::DynamicType.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],
+                        '%dyn' => @types[:dyn]}
+    }
+  end
+end
+
+RDL.reset
+require 'rdl/types/rdl_types.rb'