rdl 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 797b63a785ea5ae5e9600d8df722c66cf2a2fe17
-  data.tar.gz: dc28d44117114d21fccd6472c77f45b6efa3ae25
+  metadata.gz: b977016fb74ea728b29a3eaa767aec63ee0d6a7b
+  data.tar.gz: 45b460bc49df3fca8248811e582617229142c35d
 SHA512:
-  metadata.gz: 0ea7b41ad216861c4b05a3f7c0204a3c71b8c1ecd9ce2e8c33ab26526dc2f079358bddc0cb18af0cf4e29420fdf2d8e5a574692a1b215c491bbf26f6d6f97804
-  data.tar.gz: 18acb05e6f25b0a80716a306c6b340c3d10d6e4f2bed954e42b502b52f240808a1db03652a693f74377ee6a76c1582cc52a0d23000f599710727f5a05184e415
+  metadata.gz: 2922f3d18c4c5398a520202d8930806545e05db55a449110a9837fef4c06293dc44ef98a3c3ca70a74c639d69114ae2d93f711ad0099dd11ae9ba730ab05b7b8
+  data.tar.gz: c36055f80360a2b6cdf4d732d7d7419e5783512b9d947f08ab933358d9ed0fef34c62fdb8b1d8ed2ec34d24f2cdcf9dd12c5cf03472b550714dce384ffa56cf6

data/README.md

@@ -77,7 +77,7 @@ The beta version of RDL also has an experimental mode in which method bodies can
 file.rb:
   require 'rdl'
 
-  type '(Fixnum) -> Fixnum', typecheck_now: true
+  type '(Fixnum) -> Fixnum', typecheck: :now
   def id(x)
     "forty-two"
   end
@@ -91,7 +91,7 @@ $ ruby file.rb
 .../file.rb:5:     ^~~~~~~~~~~
 ```
 
-Passing `typecheck_now: true` to `type` checks the method body immediately or as soon as it is defined. Passing `typecheck: true` to `type` statically type checks the method body whenever it is called.
+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.
 
@@ -540,9 +540,11 @@ RDL also includes a special *bottom* type `%bot` that is a subtype of any type,
 
 # 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: true` 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.
+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, `type` can be called with `typecheck: true`, 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.
+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.
 
 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.)
 
@@ -590,6 +592,17 @@ 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:
+
+```ruby
+var_type :@f, 'Fixnum'
+var_type :@g, 'String'
+type :f, '() -> Fixnum'
+type :f=, '(Fixnum) -> Fixnum'
+type :g, '() -> String'
+type :g=, '(String) -> String'
+```
+
 ## Tuples, Finite Hashes, and Subtyping
 
 When RDL encounters a literal array in the program, it assigns it a tuple type, which allows, among other things, precise handling of multiple assignment. For example:
@@ -791,3 +804,5 @@ Copyright (c) 2014-2016, University of Maryland, College Park. All rights reserv
 * Queries, include more regexp operators aside from . and ...
 
 * Queries, allow regexp in class and method names; suggested by Andreas Adamcik, Vienna
+
+* Tag for private methods

data/lib/rdl.rb

@@ -39,8 +39,10 @@ $__rdl_aliases = Hash.new
 # method is a symbol
 $__rdl_to_wrap = Set.new
 
-# Same as $__rdl_to_wrap, but records [class, method] pairs to type check when they're defined
-$__rdl_to_typecheck_now = Set.new
+# Map from symbols to set of [class, method] pairs to type check when those symbols are rdl_do_typecheck'd
+# (or the methods are defined, for the symbol :now)
+$__rdl_to_typecheck = Hash.new
+$__rdl_to_typecheck[:now] = Set.new
 
 # List of contracts that should be applied to the next method definition
 $__rdl_deferred = []

data/lib/rdl/config.rb

@@ -5,10 +5,12 @@ class RDL::Config
 
   attr_accessor :nowrap
   attr_accessor :gather_stats
-  
+  attr_accessor :report
+
   def initialize
     @nowrap = Set.new
-    @gather_stats = true
+    @gather_stats = false
+    @report = false
   end
 
   def add_nowrap(*klasses)
@@ -18,7 +20,7 @@ class RDL::Config
   def remove_nowrap(*klasses)
     klasses.each { |klass| @nowrap.delete klass }
   end
-  
+
   # To use, copy these 3 lines to the test file of a gem
 =begin
 require_relative '../rdl3/rdl/lib/rdl.rb'
@@ -28,7 +30,7 @@ RDL::Config.instance.profile_stats
   def profile_stats(outname="/#{__FILE__[0...-3]}",outdir="")
     require 'profile'
     Profiler__.stop_profile # Leave setup out of stats
-    
+
     at_exit do
       Profiler__.stop_profile
       $__rdl_contract_switch.off {
@@ -40,7 +42,7 @@ RDL::Config.instance.profile_stats
         #   [-1] -> Contract exists for method, but method not profiled
         #   [-1, ...] -> Method profiled, but no contract exists
         totals = {}
-        
+
         puts "Retrieving Profiler Data"
         Profiler__.class_variable_get(:@@maps).values.each do |threadmap|
           threadmap.each do |key, data|
@@ -50,7 +52,7 @@ RDL::Config.instance.profile_stats
             total_data[3] += data[2]
           end
         end
-        
+
         puts "Scanning Object Space"
         kls = []
         ObjectSpace.each_object { |obj|
@@ -65,7 +67,7 @@ RDL::Config.instance.profile_stats
             totals["#{obj.class}::#{mthd.to_s}".gsub('::','#')] ||= [nil] unless mthd.to_s =~ /new/
           }
         }
-        
+
         p "Scanning RDL Contract Log"
         $__rdl_wrapped_calls.each{ |mname,ct|
           if (totals[mname]) then
@@ -76,13 +78,13 @@ RDL::Config.instance.profile_stats
             end
           end
         }
-        
+
         puts "Analyzing Statistics"
         filtered = {}
         totals.each{ |k,v|
           if (not (k=~/(rdl)|(RDL)/)) and (v[0].nil? or v[0]==-1) then filtered[k]=v end
         }
-        
+
         puts "Writing Output"
         require 'json'
         fpath = "#{outdir}/#{outname}_rdlstat.json".gsub('//','')
@@ -115,7 +117,36 @@ RDL::Config.instance.profile_stats
         puts "DONE."
       }
     end
-    
+
     Profiler__.start_profile # Restart profiler after setup
   end
-end
+end
+
+at_exit do
+  if RDL::Config.instance.report
+    typechecked = []
+    missing = []
+    $__rdl_info.info.each_pair { |klass, meths|
+      meths.each { |meth, kinds|
+        if kinds[:typecheck]
+          if kinds[:typechecked]
+            typechecked << [klass, meth]
+          else
+            missing << [klass, meth]
+          end
+        elsif kinds[:typechecked]
+          raise RuntimeError, "#{RDL::Util.pp_klass_method(klass, meth)} typechecked but not annotated to do so?!"
+        end
+      }
+    }
+    unless typechecked.empty?
+      puts "TYPECHECKED METHODS:"
+      typechecked.each { |klass, meth| puts RDL::Util.pp_klass_method(klass, meth) }
+    end
+    unless missing.empty?
+      puts unless typechecked.empty?
+      puts "METHODS ANNOTATED TO BE TYPECHECKED BUT NOT TYPECHECKED:"
+      missing.each { |klass, meth| puts RDL::Util.pp_klass_method(klass, meth) }
+    end
+  end
+end

data/lib/rdl/typecheck.rb

@@ -152,6 +152,7 @@ module RDL::Typecheck
   def self.typecheck(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?
     digest = Digest::MD5.file file
     cache_hit = (($__rdl_ruby_parser_cache.has_key? file) &&
                  ($__rdl_ruby_parser_cache[file][0] == digest))
@@ -185,13 +186,16 @@ module RDL::Typecheck
       end
       inst = {self: self_type}
       type = type.instantiate inst
-      error :arg_count_mismatch, ['method', type.args.length, 'method', args.children.length], args unless type.args.length == args.children.length
+      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
       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)
   end
 
   # The actual type checking logic.
@@ -1012,7 +1016,8 @@ RUBY
       end
       tancestor = $__rdl_info.get(ancestor_name, name, :type)
       return tancestor if tancestor
-      if (if RDL::Util.has_singleton_marker(ancestor_name) then ancestor.singleton_methods.member?(name) else ancestor.instance_methods.member?(name) end)
+      if (if RDL::Util.has_singleton_marker(ancestor_name) then ancestor.singleton_methods(false).member?(name) else ancestor.instance_methods(false).member?(name) end)
+        klass = RDL::Util.remove_singleton_marker klass if RDL::Util.has_singleton_marker klass
         error :missing_ancestor_type, [ancestor_name, klass, name], e
       end
     }

data/lib/rdl/wrap.rb

@@ -8,7 +8,7 @@ class RDL::Wrap
     meth = meth.to_sym
     while $__rdl_aliases[klass] && $__rdl_aliases[klass][meth]
       if $__rdl_info.has_any?(klass, meth, [:pre, :post, :type])
-        raise RuntimeError, "Alias #{klass}\##{meth} has contracts. Contracts are only allowed on methods, not aliases."
+        raise RuntimeError, "Alias #{RDL::Util.pp_klass_method(klass, meth)} has contracts. Contracts are only allowed on methods, not aliases."
       end
       meth = $__rdl_aliases[klass][meth]
     end
@@ -30,9 +30,8 @@ class RDL::Wrap
       klass_str = klass_str.to_s
       klass = RDL::Util.to_class klass_str
       return if wrapped? klass, meth
-      $__rdl_info.set(klass_str, meth, :source_location, klass.instance_method(meth).source_location) # get locs for nowrap meths!
       return if RDL::Config.instance.nowrap.member? klass
-      raise ArgumentError, "Attempt to wrap #{klass.to_s}\##{meth.to_s}" if klass.to_s =~ /^RDL::/
+      raise ArgumentError, "Attempt to wrap #{RDL::Util.pp_klass_method(klass, meth)}" if klass.to_s =~ /^RDL::/
       meth_old = wrapped_name(klass, meth) # meth_old is a symbol
       # return if (klass.method_defined? meth_old) # now checked above by wrapped? call
       is_singleton_method = RDL::Util.has_singleton_marker(klass_str)
@@ -55,7 +54,7 @@ class RDL::Wrap
             #{if not(is_singleton_method) then "inst[:self] = RDL::Type::NominalType.new(self.class)" end}
 #            puts "Intercepted #{full_method_name}(\#{args.join(", ")}) { \#{blk} }, inst = \#{inst.inspect}"
             meth = RDL::Wrap.resolve_alias(klass, #{meth.inspect})
-            RDL::Typecheck.typecheck(klass, meth) if $__rdl_info.get(klass, meth, :typecheck)
+            RDL::Typecheck.typecheck(klass, meth) if $__rdl_info.get(klass, meth, :typecheck) == :call
             pres = $__rdl_info.get(klass, meth, :pre)
             RDL::Contract::AndContract.check_array(pres, self, *args, &blk) if pres
             types = $__rdl_info.get(klass, meth, :type)
@@ -176,6 +175,53 @@ RUBY
       return $__rdl_parser.scan_str type
     end
   end
+
+  # called by Object#method_added (sing=false) and Object#singleton_method_added (sing=true)
+  def self.do_method_added(the_self, sing, klass, meth)
+    # Apply any deferred contracts and reset list
+    if sing
+      loc = the_self.singleton_method(meth).source_location
+    else
+      loc = the_self.instance_method(meth).source_location
+    end
+
+    if $__rdl_deferred.size > 0
+      $__rdl_info.set(klass, meth, :source_location, loc)
+      a = $__rdl_deferred
+      $__rdl_deferred = [] # Reset before doing more work to avoid infinite recursion
+      a.each { |prev_klass, kind, contract, h|
+        if RDL::Util.has_singleton_marker(klass)
+          tmp_klass = RDL::Util.remove_singleton_marker(klass)
+        else
+          tmp_klass = klass
+        end
+        raise RuntimeError, "Deferred contract from class #{prev_klass} being applied in class #{tmp_klass}" if prev_klass != tmp_klass
+        $__rdl_info.add(klass, meth, kind, contract)
+        RDL::Wrap.wrap(klass, meth) if h[:wrap]
+        unless $__rdl_info.set(klass, meth, :typecheck, h[:typecheck])
+          raise RuntimeError, "Inconsistent typecheck flag on #{RDL::Util.pp_klass_method(klass, meth)}"
+        end
+        RDL::Typecheck.typecheck(klass, meth) if h[:typecheck] == :now
+        if (h[:typecheck] && h[:typecheck] != :call)
+          $__rdl_to_typecheck[h[:typecheck]] = Set.new unless $__rdl_to_typecheck[h[:typecheck]]
+          $__rdl_to_typecheck[h[:typecheck]].add([klass, meth])
+        end
+      }
+    end
+
+    # Wrap method if there was a prior contract for it.
+    if $__rdl_to_wrap.member? [klass, meth]
+      $__rdl_to_wrap.delete [klass, meth]
+      RDL::Wrap.wrap(klass, meth)
+      $__rdl_info.set(klass, meth, :source_location, loc)
+    end
+
+    # Type check method if requested; must typecheck before wrap
+    if $__rdl_to_typecheck[:now].member? [klass, meth]
+      $__rdl_to_typecheck[:now].delete [klass, meth]
+      RDL::Typecheck.typecheck(klass, meth)
+    end
+  end
 end
 
 class Object
@@ -229,17 +275,20 @@ class Object
     }
   end
 
-  # [+klass+] may be Class, Symbol, or String
-  # [+method+] may be Symbol or String
-  # [+type+] may be Type or String
-  # [+wrap+] indicates whether the type should be enforced (true) or just recorded (false)
-  # [+typecheck+] indicates whether the method should be statically checked against this type (not yet implemented)
+  # [+ klass +] may be Class, Symbol, or String
+  # [+ method +] may be Symbol or String
+  # [+ type +] may be Type or String
+  # [+ wrap +] indicates whether the type should be enforced (true) or just recorded (false)
+  # [+ typecheck +] indicates a method that should be statically type checked, as follows
+  #    if :call, indicates method should be typechecked when called
+  #    if :now, indicates method should be typechecked immediately
+  #    if other-symbol, indicates method should be typechecked when rdl_do_typecheck(other-symbol) is called
   #
   # Set a method's type. Possible invocations:
   # type(klass, meth, type)
   # type(meth, type)
   # type(type)
-  def type(*args, wrap: true, typecheck: false, typecheck_now: false, &blk)
+  def type(*args, wrap: true, typecheck: false, &blk)
     $__rdl_contract_switch.off {
       klass, meth, type = begin
                             RDL::Wrap.process_type_args(self, *args, &blk)
@@ -260,71 +309,78 @@ class Object
 #        end
         $__rdl_info.add(klass, meth, :type, type)
         unless $__rdl_info.set(klass, meth, :typecheck, typecheck)
-          raise RuntimeError, "Inconsistent typecheck flag on #{klass}##{meth}"
+          raise RuntimeError, "Inconsistent typecheck flag on #{RDL::Util.pp_klass_method(klass, meth)}"
         end
         if wrap
           if RDL::Util.method_defined?(klass, meth) || meth == :initialize
-            RDL::Typecheck.typecheck(klass, meth) if typecheck_now
+            $__rdl_info.set(klass, meth, :source_location, RDL::Util.to_class(klass).instance_method(meth).source_location)
+            RDL::Typecheck.typecheck(klass, meth) if typecheck == :now
             RDL::Wrap.wrap(klass, meth)
           else
             $__rdl_to_wrap << [klass, meth]
-            $__rdl_to_typecheck_now << [klass, meth] if typecheck_now
+            if (typecheck && typecheck != :call)
+              $__rdl_to_typecheck[typecheck] = Set.new unless $__rdl_to_typecheck[typecheck]
+              $__rdl_to_typecheck[typecheck].add([klass, meth])
+            end
           end
         end
       else
         $__rdl_deferred << [klass, :type, type, {wrap: wrap,
-                                                 typecheck: typecheck,
-                                                 typecheck_now: typecheck_now}]
+                                                 typecheck: typecheck}]
       end
     }
   end
 
+  # [+ klass +] is the class containing the variable; self if omitted; ignored for local and global variables
+  # [+ var +] is a symbol or string containing the name of the variable
+  # [+ typ +] is a string containing the type
   def var_type(klass=self, var, typ)
     raise RuntimeError, "Variable cannot begin with capital" if var.to_s =~ /^[A-Z]/
     return if var.to_s =~ /^[a-z]/ # local variables handled specially, inside type checker
-    raise Runtimeerror, "Global variables can't be typed in a class" unless klass = self
+    raise RuntimeError, "Global variables can't be typed in a class" unless klass = self
     klass = RDL::Util::GLOBAL_NAME if var.to_s =~ /^\$/
     unless $__rdl_info.set(klass, var, :type, $__rdl_parser.scan_str("#T #{typ}"))
       raise RuntimeError, "Type already declared for #{var}"
     end
   end
 
-  def self.method_added(meth)
-    $__rdl_contract_switch.off {
-      klass = self.to_s
-      klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+  # In the following three methods
+  # [+ args +] is a sequence of symbol, typ. attr_reader is called for each symbol,
+  # and var_type is called to assign the immediately following type to the
+  # attribute named after that symbol.
+  def attr_accessor_type(*args)
+    args.each_slice(2) { |name, typ|
+      attr_accessor name
+      var_type ("@" + name.to_s), typ
+      type name, "() -> #{typ}"
+      type name.to_s + "=", "(#{typ}) -> #{typ}"
+    }
+  end
 
-      # Apply any deferred contracts and reset list
-      if $__rdl_deferred.size > 0
-        a = $__rdl_deferred
-        $__rdl_deferred = [] # Reset before doing more work to avoid infinite recursion
-        a.each { |prev_klass, kind, contract, h|
-          raise RuntimeError, "Deferred contract from class #{prev_klass} being applied in class #{klass}" if prev_klass != klass
-          $__rdl_info.add(klass, meth, kind, contract)
-          RDL::Wrap.wrap(klass, meth) if h[:wrap]
-          RDL::Typecheck.typecheck(klass, meth) if h[:typecheck_now]
-          unless $__rdl_info.set(klass, meth, :typecheck, h[:typecheck])
-            raise RuntimeError, "Inconsistent typecheck flag on #{klass}##{meth}"
-          end
+  def attr_reader_type(*args)
+    args.each_slice(2) { |name, typ|
+      attr_reader name
+      var_type ("@" + name.to_s), typ
+      type name, "() -> #{typ}"
+    }
+  end
 
-# It turns out Ruby core/stdlib don't always follow this convention...
-#          if (kind == :type) && (meth.to_s[-1] == "?") && (contract.ret != $__rdl_type_bool)
-#            warn "#{RDL::Util.pp_klass_method(klass, meth)}: methods that end in ? should have return type %bool"
-#          end
-        }
-      end
+  alias_method :attr_type, :attr_reader_type
 
-      # Wrap method if there was a prior contract for it.
-      if $__rdl_to_wrap.member? [klass, meth]
-        $__rdl_to_wrap.delete [klass, meth]
-        RDL::Wrap.wrap(klass, meth)
-      end
+  def attr_writer_type(*args)
+    args.each_slice(2) { |name, typ|
+      attr_writer name
+      var_type ("@" + name.to_s), typ
+      type name.to_s + "=", "(#{typ}) -> #{typ}"
+    }
+  end
 
-      # Type check method if requested; must typecheck before wrap
-      if $__rdl_to_typecheck_now.member? [klass, meth]
-        $__rdl_to_typecheck_now.delete [klass, meth]
-        RDL::Typecheck.typecheck(klass, meth)
-      end
+
+  def self.method_added(meth)
+    $__rdl_contract_switch.off {
+      klass = self.to_s
+      klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+      RDL::Wrap.do_method_added(self, false, klass, meth)
     }
   end
 
@@ -333,33 +389,7 @@ class Object
       klass = self.to_s
       klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
       sklass = RDL::Util.add_singleton_marker(klass)
-
-      # Apply any deferred contracts and reset list
-      if $__rdl_deferred.size > 0
-        a = $__rdl_deferred
-        $__rdl_deferred = [] # Reset before doing more work to avoid infinite recursion
-        a.each { |prev_klass, kind, contract, h|
-          raise RuntimeError, "Deferred contract from class #{prev_klass} being applied in class #{klass}" if prev_klass != klass
-          $__rdl_info.add(sklass, meth, kind, contract)
-          RDL::Wrap.wrap(sklass, meth) if h[:wrap]
-          RDL::Typecheck.typecheck(sklass, meth) if h[:typecheck_now]
-          unless $__rdl_info.set(klass, meth, :typecheck, h[:typecheck])
-            raise RuntimeError, "Inconsistent typecheck flag on #{klass}##{meth}"
-          end
-        }
-      end
-
-      # Wrap method if there was a prior contract for it.
-      if $__rdl_to_wrap.member? [sklass, meth]
-        $__rdl_to_wrap.delete [sklass, meth]
-        RDL::Wrap.wrap(sklass, meth)
-      end
-
-      # Type check method if requested
-      if $__rdl_to_typecheck_now.member? [sklass, meth]
-        $__rdl_to_typecheck_now.delete [sklass, meth]
-        RDL::Typecheck.typecheck(sklass, meth)
-      end
+      RDL::Wrap.do_method_added(self, true, sklass, meth)
     }
   end
 
@@ -498,5 +528,12 @@ class Object
     }
   end
 
+  # Type check all methods that had annotation `typecheck: sym' at type call
+  def rdl_do_typecheck(sym)
+    $__rdl_to_typecheck[sym].each { |klass, meth|
+      RDL::Typecheck.typecheck(klass, meth)
+    }
+    $__rdl_to_typecheck[sym] = Array.new
+  end
 
 end

data/rdl.gemspec

@@ -4,8 +4,8 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '2.0.0.rc1'
-  s.date        = '2016-07-17'
+  s.version     = '2.0.0.rc2'
+  s.date        = '2016-07-19'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
 RDL is a gem that adds types and contracts to Ruby. RDL includes extensive

data/test/test_typecheck.rb

@@ -41,54 +41,68 @@ class TestTypecheck < Minitest::Test
 
   def test_def
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum", typecheck_now: true
+      type "(Fixnum) -> Fixnum", typecheck: :now
       def def_ff(x) x; end
     }
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) -> Fixnum", typecheck_now: true
+        type "(Fixnum) -> Fixnum", typecheck: :now
         def def_fs(x) "42"; end
       }
     }
 
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum", typecheck_now: true
+      type "(Fixnum) -> Fixnum", typecheck: :now
       def def_ff2(x) x; end
     }
     assert_equal 42, def_ff2(42)
 
     self.class.class_eval {
-      type "(Fixnum) -> Fixnum", typecheck: true
+      type "(Fixnum) -> Fixnum", typecheck: :call
       def def_fs2(x) "42"; end
     }
     assert_raises(RDL::Typecheck::StaticTypeError) { def_fs2(42) }
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) -> Fixnum", typecheck_now: true
+        type "(Fixnum) -> Fixnum", typecheck: :now
         def def_ff3(x, y) 42; end
       }
     }
+
+    self.class.class_eval {
+      type "(Fixnum) -> Fixnum", typecheck: :later
+      def def_ff4(x, y) 42; end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) { rdl_do_typecheck :later }
   end
 
   def test_defs
     self.class.class_eval {
-      type "(Fixnum) -> Class", typecheck_now: true
+      type "(Fixnum) -> Class", typecheck: :now
       def self.defs_ff(x) self; end
     }
 
     self.class.class_eval {
-      type "() -> Class", typecheck_now: true
+      type "() -> Class", typecheck: :now
       def self.defs_nn() defs_ff(42); end
     }
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "() -> Class", typecheck_now: true
+        type "() -> Class", typecheck: :now
         def self.defs_other() fdsakjfhds(42); end
       }
     }
+
+    self.class.class_eval {
+      type "(Fixnum) -> Fixnum", typecheck: :later
+      def self.defs_ff2(x, y) 42; end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) { rdl_do_typecheck :later }
   end
 
   def test_lits
@@ -107,7 +121,7 @@ class TestTypecheck < Minitest::Test
 
   def test_empty
     self.class.class_eval {
-      type "() -> nil", typecheck_now: true
+      type "() -> nil", typecheck: :now
       def empty() end
     }
   end
@@ -115,10 +129,10 @@ class TestTypecheck < Minitest::Test
   def test_dstr_xstr
     # Hard to read if these are inside of strings, so leave like this
     self.class.class_eval {
-      type "() -> String", typecheck_now: true
+      type "() -> String", typecheck: :now
       def dstr() "Foo #{42} Bar #{43}"; end
 
-      type "() -> String", typecheck_now: true
+      type "() -> String", typecheck: :now
       def xstr() `ls #{42}`; end
     }
   end
@@ -130,7 +144,7 @@ class TestTypecheck < Minitest::Test
   def test_dsym
     # Hard to read if these are inside of strings, so leave like this
     self.class.class_eval {
-      type "() -> Symbol", typecheck_now: true
+      type "() -> Symbol", typecheck: :now
       def dsym() :"foo#{42}"; end
     }
   end
@@ -140,7 +154,7 @@ class TestTypecheck < Minitest::Test
 
     self.class.class_eval {
       # Hard to read if these are inside of strings, so leave like this
-      type "() -> Regexp", typecheck_now: true
+      type "() -> Regexp", typecheck: :now
       def regexp2() /foo#{42}bar#{"baz"}/i; end
     }
   end
@@ -166,18 +180,18 @@ class TestTypecheck < Minitest::Test
   def test_self
     # These need to be inside an actual class
     self.class.class_eval {
-      type "() -> self", typecheck_now: true
+      type "() -> self", typecheck: :now
       def self1() self; end
     }
 
     self.class.class_eval {
-      type "() -> self", typecheck_now: true
+      type "() -> self", typecheck: :now
       def self2() TestTypecheck.new; end
     }
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "() -> self", typecheck_now: true
+        type "() -> self", typecheck: :now
         def self3() Object.new; end
       }
     }
@@ -199,19 +213,19 @@ class TestTypecheck < Minitest::Test
 
   def test_lvar
     self.class.class_eval {
-      type "(Fixnum, String) -> Fixnum", typecheck_now: true
+      type "(Fixnum, String) -> Fixnum", typecheck: :now
       def lvar1(x, y) x; end
     }
 
     self.class.class_eval {
-      type "(Fixnum, String) -> String", typecheck_now: true
+      type "(Fixnum, String) -> String", typecheck: :now
       def lvar2(x, y) y; end
     }
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       # really a send
       self.class.class_eval {
-        type "(Fixnum, String) -> String", typecheck_now: true
+        type "(Fixnum, String) -> String", typecheck: :now
         def lvar3(x, y) z; end
       }
     }
@@ -235,12 +249,12 @@ class TestTypecheck < Minitest::Test
     assert_equal $__rdl_fixnum_type, do_tc("var_type :x, 'Fixnum'; x = 3; x", env: @env)
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("var_type :x, 'Fixnum'; x = 'three'", env: @env) }
     self.class.class_eval {
-      type "(Fixnum) -> nil", typecheck_now: true
+      type "(Fixnum) -> nil", typecheck: :now
       def lvar_type_ff(x) x = 42; nil; end
     }
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) -> nil", typecheck_now: true
+        type "(Fixnum) -> nil", typecheck: :now
         def lvar_type_ff2(x) x = "forty-two"; nil; end
       }
     }
@@ -508,7 +522,7 @@ class TestTypecheck < Minitest::Test
 
   def test_yield
     self.class.class_eval {
-      type "(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum", typecheck_now: true
+      type "(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum", typecheck: :now
       def _yield1(x)
         yield x
       end
@@ -516,7 +530,7 @@ class TestTypecheck < Minitest::Test
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum", typecheck_now: true
+        type "(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum", typecheck: :now
         def _yield2(x)
           yield 'forty-two'
         end
@@ -525,7 +539,7 @@ class TestTypecheck < Minitest::Test
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) { (Fixnum) -> String } -> Fixnum", typecheck_now: true
+        type "(Fixnum) { (Fixnum) -> String } -> Fixnum", typecheck: :now
         def _yield3(x)
           yield 42
         end
@@ -534,7 +548,7 @@ class TestTypecheck < Minitest::Test
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) -> Fixnum", typecheck_now: true
+        type "(Fixnum) -> Fixnum", typecheck: :now
         def _yield4(x)
           yield 42
         end
@@ -543,7 +557,7 @@ class TestTypecheck < Minitest::Test
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) { (Fixnum) { (Fixnum) -> Fixnum } -> Fixnum } -> Fixnum", typecheck_now: true
+        type "(Fixnum) { (Fixnum) { (Fixnum) -> Fixnum } -> Fixnum } -> Fixnum", typecheck: :now
         def _yield5(x)
           yield 42
         end
@@ -552,14 +566,14 @@ class TestTypecheck < Minitest::Test
   end
 
   # class Sup1
-  #   type '(Fixnum) -> Fixnum', typecheck: true
+  #   type '(Fixnum) -> Fixnum', typecheck: :call
   #   def foo(y)
   #     return y
   #   end
   # end
   #
   # class Sup2 < Sup1
-  #   type '(Fixnum) -> Fixnum', typecheck: true
+  #   type '(Fixnum) -> Fixnum', typecheck: :call
   #   def foo(x)
   #     super(x+1)
   #   end
@@ -693,7 +707,7 @@ class TestTypecheck < Minitest::Test
 
   def test_return
     assert self.class.class_eval {
-      type "(Fixnum) -> Fixnum", typecheck_now: true
+      type "(Fixnum) -> Fixnum", typecheck: :now
       def return_ff(x)
         return 42
       end
@@ -701,7 +715,7 @@ class TestTypecheck < Minitest::Test
 
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
-        type "(Fixnum) -> Fixnum", typecheck_now: true
+        type "(Fixnum) -> Fixnum", typecheck: :now
         def return_ff2(x)
           return "forty-two"
         end
@@ -890,4 +904,30 @@ class TestTypecheck < Minitest::Test
     assert_equal tt("Hash<Symbol or String, Fixnum or String>"), do_tc("x = {'a' => 1, **_kwsplathsf, b: 'two'}", env: @env)
   end
 
+  def test_attr_etc
+    self.class.class_eval {
+      attr_reader_type :f_attr_reader, "Fixnum", :f_attr_reader2, "String"
+      attr_writer_type :f_attr_writer, "Fixnum"
+      attr_type :f_attr, "Fixnum"
+      attr_accessor_type :f_attr_accessor, "Fixnum"
+    }
+    assert_equal $__rdl_fixnum_type, do_tc("@f_attr_reader", env: @env)
+    assert_equal $__rdl_fixnum_type, do_tc("TestTypecheck.new.f_attr_reader", env: @env)
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("TestTypecheck.new.f_attr_reader = 4", env: @env) }
+    assert_equal $__rdl_string_type, do_tc("@f_attr_reader2", env: @env)
+    assert_equal $__rdl_string_type, do_tc("TestTypecheck.new.f_attr_reader2", env: @env)
+
+    assert_equal $__rdl_fixnum_type, do_tc("@f_attr", env: @env) # same as attr_reader
+    assert_equal $__rdl_fixnum_type, do_tc("TestTypecheck.new.f_attr", env: @env)
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("TestTypecheck.new.f_attr = 42", env: @env) }
+
+    assert_equal @t3, do_tc("@f_attr_writer = 3", env: @env)
+    assert_equal $__rdl_fixnum_type, do_tc("TestTypecheck.new.f_attr_writer = 3", env: @env)
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("TestTypecheck.new.f_attr_writer", env: @env) }
+
+    assert_equal $__rdl_fixnum_type, do_tc("@f_attr_accessor", env: @env)
+    assert_equal $__rdl_fixnum_type, do_tc("TestTypecheck.new.f_attr_accessor", env: @env)
+    assert_equal $__rdl_fixnum_type, do_tc("TestTypecheck.new.f_attr_accessor = 42", env: @env)
+  end
+
 end

data/types/ruby-2.x/module.rb

@@ -0,0 +1,83 @@
+class Module
+  rdl_nowrap
+
+  type 'self.constants', '() -> Array<Fixnum>' # also constants(inherited), but undocumented
+  type 'self.nesting', '() -> Array<Module>'
+  type 'self.new', '() -> Module'
+  type 'self.new', '() { (Module) -> %any } -> Module'
+
+  type :<, '(Module other) -> %bool or nil'
+  type :<=, '(Module other) -> %bool or nil'
+  type :<=>, '(Module other) -> -1 or 0 or 1 or nil'
+  type :==, '(%any other) -> %bool'
+  type :equal, '(%any other) -> %bool'
+  type :eql, '(%any other) -> %bool'
+  type :===, '(%any other) -> %bool'
+  type :>, '(Module other) -> %bool or nil'
+  type :>=, '(Module other) -> %bool or nil'
+  type :ancestors, '() -> Array<Module>'
+  type :autoload, '(Symbol module, String filename) -> nil'
+  type :autoload?, '(Symbol name) -> String or nil'
+  type :class_eval, '(String, ?String filename, ?Fixnum lineno) -> %any'
+  type :class_exec, '(*%any args) { (*%any args) -> %any } -> %any'
+  type :class_variable_defined?, '(Symbol or String) -> %bool'
+  type :class_variable_get, '(Symbol or String) -> %any'
+  type :class_variable_set, '(Symbol or String, %any) -> %any'
+  type :class_variables, '(?%bool inherit) -> Array<Symbol>'
+  type :const_defined?, '(Symbol or String, ?%bool inherit) -> %bool'
+  type :const_get, '(Symbol or String, ?%bool inherit) -> %any'
+  type :const_missing, '(Symbol) -> %any'
+  type :const_set, '(Symbol or String, %any) -> %any'
+  type :constants, '(?%bool inherit) -> Array<Symbol>'
+  type :freeze, '() -> self'
+  type :include, '(*Module) -> self'
+  type :include?, '(Module) -> %bool'
+  type :included_modules, '() -> Array<Module>'
+  rdl_alias :inspect, :to_s
+  type :instance_method, '(Symbol) -> UnboundMethod'
+  type :instance_methods, '(?%bool include_super) -> Array<Symbol>'
+  type :method_defined?, '(Symbol or String) -> %bool'
+  type :module_eval, '(String, ?String filename, ?Fixnum lineno) -> %any' # matches rdoc example but not type
+  type :module_exec, '(*%any args) { (*%any args) -> %any } -> %any'
+  type :name, '() -> String'
+  type :prepend, '(*Module) -> self'
+  type :private_class_method, '(*(Symbol or String)) -> self'
+  type :private_constant, '(*Symbol) -> self'
+  type :private_instance_methods, '(?%bool include_super) -> Array<Symbol>'
+  type :private_method_defined?, '(Symbol or String) -> %bool'
+  type :protected_instance_methods, '(?%bool include_super) -> Array<Symbol>'
+  type :protected_method_defined?, '(Symbol or String) -> %bool'
+  type :public_class_method, '(*(Symbol or String)) -> self'
+  type :public_constant, '(*Symbol) -> self'
+  type :public_instance_method, '(Symbol) -> UnboundMethod'
+  type :public_instance_methods, '(?%bool include_super) -> Array<Symbol>'
+  type :public_method_defined?, '(Symbol or String) -> %bool'
+  type :remove_class_variable, '(Symbol) -> %any'
+  type :singleton_class?, '() -> %bool'
+  type :to_s, '() -> String'
+# private methods below here
+  type :alias_method, '(Symbol new_name, Symbol old_name) -> self'
+  type :append_features, '(Module) -> self'
+  rdl_alias :attr, :attr_reader
+  type :attr_accessor, '(*(Symbol or String)) -> nil'
+  type :attr_reader, '(*(Symbol or String)) -> nil'
+  type :attr_writer, '(*(Symbol or String)) -> nil'
+  type :define_method, '(Symbol, Method) -> Symbol'
+  type :define_method, '(Symbol) { (*%any) -> %any } -> Symbol'
+  type :extend_object, '(%any) -> %any'
+  type :extended, '(Module othermod) -> %any'
+  type :included, '(Module othermod) -> %any'
+  type :method_added, '(Symbol method_name) -> %any'
+  type :method_removed, '(Symbol method_name) -> %any'
+  type :module_function, '(*(Symbol or String)) -> self'
+  type :prepend_features, '(Module) -> self'
+  type :prepended, '(Module othermod) -> %any'
+  type :private, '(*(Symbol or String)) -> self'
+  type :protected, '(*(Symbol or String)) -> self'
+  type :public, '(*(Symbol or String)) -> self'
+  type :refine, '(Class) { (%any) -> %any } -> self' # ??
+  type :remove_const, '(Symbol) -> %any'
+  type :remove_method, '(Symbol or String) -> self'
+  type :undef_method, '(Symbol or String) -> self'
+  type :using, '(Module) -> self'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdl
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc1
+  version: 2.0.0.rc2
 platform: ruby
 authors:
 - Jeffrey S. Foster
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-17 00:00:00.000000000 Z
+date: 2016-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -206,6 +206,7 @@ files:
 - types/ruby-2.x/marshal.rb
 - types/ruby-2.x/matchdata.rb
 - types/ruby-2.x/math.rb
+- types/ruby-2.x/module.rb
 - types/ruby-2.x/nil.rb
 - types/ruby-2.x/numeric.rb
 - types/ruby-2.x/object.rb