Add type inference

.gitignore

@@ -1,45 +1,46 @@
-{\rtf1\ansi\ansicpg1252\cocoartf1265\cocoasubrtf210
-{\fonttbl\f0\fnil\fcharset0 Consolas;}
-{\colortbl;\red255\green255\blue255;\red38\green38\blue38;}
-\margl1440\margr1440\vieww10800\viewh8400\viewkind0
-\deftab720
-\pard\pardeftab720
+###################
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
 
-\f0\fs24 \cf2 # Compiled source #\
-###################\
-*.com\
-*.class\
-*.dll\
-*.exe\
-*.o\
-*.so\
-\'a0\
-# Packages #\
-############\
-# it's better to unpack these files and commit the raw source\
-# git has its own built in compression methods\
-*.7z\
-*.dmg\
-*.gz\
-*.iso\
-*.jar\
-*.rar\
-*.tar\
-*.zip\
-*.gem\
-\'a0\
-# Logs and databases #\
-######################\
-*.log\
-*.sql\
-*.sqlite\
-\'a0\
-# OS generated files #\
-######################\
-.DS_Store\
-.DS_Store?\
-._*\
-.Spotlight-V100\
-.Trashes\
-ehthumbs.db\
-Thumbs.db}
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+*.gem
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+### Editors
+.#*
+
+### Ruby
+*.gem
+
+### RDL
+*.csv

.rubocop.yml

@@ -0,0 +1,5 @@
+Metrics/MethodLength:
+  Max: 30
+
+Lint/BooleanSymbol:
+  Enabled: false

.travis.yml

@@ -2,22 +2,6 @@ language: ruby
 gemfile:
   - gemfiles/Gemfile.travis
 rvm:
-  - 2.1.1
-  - 2.1.6
-  - 2.1.7
-  - 2.1.8
-  - 2.2.0
-  - 2.2.1
-  - 2.2.2
-  - 2.2.3
-  - 2.2.4
-  - 2.2.5
-  - 2.2.6
-  - 2.3.0
-  - 2.3.1
-  - 2.3.2
-  - 2.3.3
-  - 2.3.4
   - 2.4.0
   - 2.4.1
   - 2.4.2
@@ -27,6 +11,9 @@ rvm:
   - 2.5.5
   - 2.6.2
   - 2.6.3
+  - 2.6.4
+  - 2.6.5
+  - 2.7.0
 notifications:
   email:
     recipients:

README.md

@@ -580,7 +580,7 @@ Value types can also be declared as optional, indicating that the key/value pair
 ```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`. 
+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
@@ -734,7 +734,7 @@ 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.
+* *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`.
 
@@ -762,6 +762,7 @@ RDL's static type checker makes some assumptions that should hold unless your Ru
 * `Class#===` is not redefined
 * `Proc#call` is not redefined
 * `Object#class` is not redefined
+* Methods that take blocks with externally visible effects do not store those blocks and then call them later
 
 (More assumptions will be added here as they are added to RDL...)
 

gemfiles/Gemfile.travis

@@ -3,3 +3,8 @@ source 'https://rubygems.org'
 gem 'rake'
 gem 'minitest'
 gem 'parser'
+gem 'sql-parser'
+gem 'method_source'
+gem 'colorize'
+gem 'coderay'
+gem 'parlour'

lib/rdl.rb

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

lib/rdl/boot.rb

@@ -2,11 +2,17 @@
 require 'digest'
 require 'set'
 require 'parser/current'
+#require 'method_source'
+require 'colorize'
+require 'pathname'
+require 'rake'
+require 'net/http'
 
 module RDL
 end
 
 require 'rdl/config.rb'
+require 'rdl/logging.rb'
 def RDL.config
   yield(RDL::Config.instance)
 end
@@ -49,6 +55,17 @@ module RDL::Globals
   @to_typecheck = Hash.new
   @to_typecheck[:now] = Set.new
 
+  # Map from symbols to set of [class, method] pairs to infer when those symbols are rdl_do_infer'd
+  # (or the methods are defined, for the symbol :now)
+  @to_infer = Hash.new
+  @to_infer[:now] = Set.new
+
+  ## List of [klass, method] pairs for which we have generated constraints.
+  ## That is, if we look up RDL::Globals.info.get(klass, meth, :type), we will get a single MethodType
+  ## composed of VarTypes with constraints.
+  ## TODO: add inst/class vars to this list?
+  @constrained_types = []
+
   # Map from symbols to Array<Proc> where the Procs are called when those symbols are rdl_do_typecheck'd
   @to_do_at = Hash.new
 
@@ -59,13 +76,29 @@ module RDL::Globals
   @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 = {}
+  @comp_type_map = Hash.new
 
   # Map from ActiveRecord table names (symbols) to their schema types, which should be a Table type
-  @ar_db_schema = {}
+  @ar_db_schema = Hash.new
 
   # Map from Sequel table names (symbols) to their schema types, which should be a Table type
-  @seq_db_schema = {}
+  @seq_db_schema = Hash.new
+
+  # Array<[String, String]>, where each first string is a class name and each second one is a method name.
+  # klass/method pairs here should not be inferred.
+  @no_infer_meths = []
+
+  # Array<String> of absolute file paths for files that should not be inferred.
+  @no_infer_files = []
+
+  # If non-nil, should be a symbol. Added, untyped methods will be tagged
+  # with that symbol
+  @infer_added = nil
+
+  # Hash<Module module, [Class/Module class/module_name, :include or :extend]>
+  # Map from module names k to pairs [class/module v, :include/:extend] indicating the module
+  # k was included/extended in v
+  @module_mixees = Hash.new
 end
 
 class << RDL::Globals # add accessors and readers for module variables
@@ -75,12 +108,19 @@ class << RDL::Globals # add accessors and readers for module variables
   attr_reader :aliases
   attr_accessor :to_wrap
   attr_accessor :to_typecheck
+  attr_accessor :to_infer
+  attr_accessor :constrained_types
   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
+  attr_accessor :no_infer_meths
+  attr_accessor :no_infer_files
+  attr_accessor :infer_added
+  attr_accessor :infer_added_filter_dirs
+  attr_accessor :module_mixees
 end
 
 # Create switches to control whether wrapping happens and whether
@@ -122,6 +162,7 @@ class << RDL::Globals
 require 'rdl/types/type_query.rb'
 require 'rdl/types/union.rb'
 require 'rdl/types/var.rb'
+require 'rdl/types/choice.rb' ## depends on var.rb
 require	'rdl/types/vararg.rb'
 require 'rdl/types/wild_query.rb'
 require	'rdl/types/string.rb'
@@ -133,9 +174,13 @@ class << RDL::Globals
 require 'rdl/contracts/proc.rb'
 
 require 'rdl/util.rb'
+require 'rdl/class_indexer.rb'
 require 'rdl/wrap.rb'
 require 'rdl/query.rb'
 require 'rdl/typecheck.rb'
+require 'rdl/reporting/reporting.rb'
+require 'rdl/constraint.rb'
+require 'rdl/heuristics.rb'
 #require_relative 'rdl/stats.rb'
 
 class << RDL::Globals
@@ -148,17 +193,28 @@ class << RDL::Globals
 module RDL
   def self.reset
     RDL::Globals.module_eval {
+      RDL::Config.reset
       @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_infer = Hash.new
+      @to_infer[:now] = Set.new
+      @constrained_types = []
       @to_do_at = Hash.new
+      @deferred = []
+      # @dep_types = []
+      # @comp_type_map = Hash.new
       @ar_db_schema = Hash.new
       @seq_db_schema = Hash.new
-      @deferred = []
+      @no_infer_meths = []
+      @no_infer_files = []
+      @infer_added = nil
+      # @module_mixees = Hash.new - resetting this breaks test cases that assume
+      # we know which modules are mixed into which other modules
 
       @parser = RDL::Type::Parser.new
 

lib/rdl/boot_rails.rb

@@ -17,3 +17,4 @@ def self.params_type(typs); end
 else
   raise RuntimeError, "Don't know what to do in Rails environment #{Rails.env}"
 end
+