rdl 2.0.0.rc2 → 2.0.0.rc3

data/lib/rdl/types/singleton.rb

@@ -53,12 +53,7 @@ module RDL::Type
     end
 
     def <=(other)
-      other = other.canonical
-      other.instance_of?(TopType) ||
-        (@val.nil? && (not (other.instance_of?(SingletonType)))) ||
-        (other.instance_of?(SingletonType) && other.val == @val) ||
-        (other.instance_of?(UnionType) && other.types.any? { |ot| self <= ot }) ||
-        (@nominal <= other)
+      return Type.leq(self, other)
     end
 
     def member?(obj, *args)

data/lib/rdl/types/structural.rb

@@ -34,16 +34,7 @@ module RDL::Type
     end
 
     def <=(other)
-      other = other.canonical
-      return true if other.instance_of? TopType
-      # in theory a StructuralType could contain all the methods of a NominalType or GenericType,
-      # but it seems unlikely in practice, so disallow this case.
-      return RuntimeError, "Structural subtype can't be subtype of #{other.class}" unless other.instance_of? StructuralType
-      # allow width subtyping
-      other.methods.each_pair { |m, t|
-        return false unless @methods.has_key?(m) && @methods[m] <= t
-      }
-      return true
+      return Type.leq(self, other)
     end
 
     def member?(obj, *args)

data/lib/rdl/types/top.rb

@@ -35,8 +35,7 @@ module RDL::Type
     end
 
     def <=(other)
-      other = other.canonical
-      other.instance_of? TopType
+      return Type.leq(self, other)
     end
 
     def member?(obj, *args)

data/lib/rdl/types/tuple.rb

@@ -3,8 +3,8 @@ module RDL::Type
   class TupleType < Type
     attr_reader :params
     attr_reader :array   # either nil or array type if self has been promoted to array
-    attr_reader :ubounds # upper bounds this tuple has been compared with using <=
-    attr_reader :lbounds # lower bounds...
+    attr_accessor :ubounds # upper bounds this tuple has been compared with using <=
+    attr_accessor :lbounds # lower bounds...
 
     # no caching because array might be mutated
     def initialize(*params)
@@ -58,23 +58,7 @@ module RDL::Type
     end
 
     def <=(other)
-      return @array <= other if @array
-      other = other.canonical
-      return true if other.instance_of? TopType
-      other = other.array if other.instance_of?(TupleType) && other.array
-      if other.instance_of? TupleType
-        # Tuples are immutable, so covariant subtyping allowed
-        return false unless @params.length == other.params.length
-        return false unless @params.zip(other.params).all? { |left, right| left <= right }
-        # subyping check passed
-        ubounds << other
-        other.lbounds << self
-        return true
-      elsif (other.instance_of? GenericType) && (other.base == $__rdl_array_type)
-        r = promote!
-        return (self <= other) && r
-      end
-      return false
+      return Type.leq(self, other)
     end
 
     def member?(obj, *args)

data/lib/rdl/types/type.rb

@@ -29,5 +29,228 @@ module RDL::Type
       return self
     end
 
+    # [+ other +] is a Type
+    # [+ inst +] is a Hash<Symbol, Type> representing an instantiation
+    # [+ ileft +] is a %bool
+    # if inst is nil, returns self <= other
+    # if inst is non-nil and ileft, returns inst(self) <= other, possibly mutating inst to make this true
+    # if inst is non-nil and !ileft, returns self <= inst(other), again possibly mutating inst
+    def self.leq(left, right, inst=nil, ileft=true)
+      left = inst[left.name] if inst && ileft && left.is_a?(VarType) && inst[left.name]
+      right = inst[right.name] if inst && !ileft && right.is_a?(VarType) && inst[right.name]
+      left = left.type if left.is_a? DependentArgType
+      right = right.type if right.is_a? DependentArgType
+      left = left.type if left.is_a? NonNullType # ignore nullness!
+      right = right.type if right.is_a? NonNullType
+      left = left.canonical
+      right = right.canonical
+
+      # top and bottom
+      return true if left.is_a? BotType
+      return true if right.is_a? TopType
+
+      # type variables
+      begin inst.merge!(left.name => right); return true end if inst && ileft && left.is_a?(VarType)
+      begin inst.merge!(right.name => left); return true end if inst && !ileft && right.is_a?(VarType)
+      if left.is_a?(VarType) && right.is_a?(VarType)
+        return left.name == right.name
+      end
+
+      # union
+      return left.types.all? { |t| leq(t, right, inst, ileft) } if left.is_a?(UnionType)
+      if right.instance_of?(UnionType)
+        right.types.each { |t|
+          # return true at first match, updating inst accordingly to first succeessful match
+          new_inst = inst.dup unless inst.nil?
+          if leq(left, t, new_inst, ileft)
+            inst.update(new_inst) unless inst.nil?
+            return true
+          end
+        }
+        return false
+      end
+
+      # nominal
+      return left.klass.ancestors.member?(right.klass) if left.is_a?(NominalType) && right.is_a?(NominalType)
+      if left.is_a?(NominalType) && right.is_a?(StructuralType)
+        right.methods.each_pair { |m, t|
+          return false unless left.klass.method_defined? m
+          types = $__rdl_info.get(left.klass, m, :type)
+          if types
+            return false unless types.all? { |tlm| leq(tlm, t, nil, ileft) }
+            # inst above is nil because the method types inside the class and
+            # inside the structural type have an implicit quantifier on them. So
+            # even if we're allowed to instantiate type variables we can't do that
+            # inside those types
+          end
+        }
+        return true
+      end
+
+      # singleton
+      return left.val == right.val if left.is_a?(SingletonType) && right.is_a?(SingletonType)
+      return true if left.is_a?(SingletonType) && left.val.nil? # right cannot be a SingletonType due to above conditional
+      return leq(left.nominal, right, inst, ileft) if left.is_a?(SingletonType) # fall through case---use nominal type for reasoning
+
+      # generic
+      if left.is_a?(GenericType) && right.is_a?(GenericType)
+        formals, variance, _ = $__rdl_type_params[left.base.name]
+        # do check here to avoid hiding errors if generic type written
+        # with wrong number of parameters but never checked against
+        # instantiated instances
+        raise TypeError, "No type parameters defined for #{base.name}" unless formals
+        return false unless left.base == right.base
+        return variance.zip(left.params, right.params).all? { |v, tl, tr|
+          case v
+          when :+
+            leq(tl, tr, inst, ileft)
+          when :-
+            leq(tr, tl, inst, !ileft)
+          when :~
+            leq(tl, tr, inst, ileft) && leq(tr, tl, inst, !ileft)
+          else
+            raise RuntimeError, "Unexpected variance #{v}" # shouldn't happen
+          end
+        }
+      end
+      if left.is_a?(GenericType) && right.is_a?(StructuralType)
+        # similar to logic above for leq(NominalType, StructuralType, ...)
+        formals, variance, _ = $__rdl_type_params[left.base.name]
+        raise TypeError, "No type parameters defined for #{base.name}" unless formals
+        base_inst = Hash[*formals.zip(left.params).flatten] # instantiation for methods in base's class
+        klass = left.base.klass
+        right.methods.each_pair { |meth, t|
+          return false unless klass.method_defined? meth
+          types = $__rdl_info.get(klass, meth, :type)
+          if types
+            return false unless types.all? { |tlm| leq(tlm.instantiate(base_inst), t, nil, ileft) }
+          end
+        }
+        return true
+      end
+      # Note we do not allow raw subtyping leq(GenericType, NominalType, ...)
+
+      # method
+      if left.is_a?(MethodType) && right.is_a?(MethodType)
+        return false unless left.args.size == right.args.size
+        return false unless left.args.zip(right.args).all? { |tl, tr| leq(tr, tl, inst, !ileft) } # contravariance
+        return false unless leq(left.ret, right.ret, inst, ileft) # covariance
+        if left.block && right.block
+          return leq(right.block, left.block, inst, !ileft) # contravariance
+        elsif left.block.nil? && right.block.nil?
+          return true
+        else
+          return false # one has a block and the other doesn't
+        end
+      end
+
+      # structural
+      if left.is_a?(StructuralType) && right.is_a?(StructuralType)
+        # allow width subtyping - methods of right have to be in left, but not vice-versa
+        return right.methods.all? { |m, t|
+          # in recursive call set inst to nil since those method types have implicit quantifier
+          left.methods.has_key?(m) && leq(left.methods[m], t, nil, ileft)
+        }
+      end
+      # Note we do not allow a structural type to be a subtype of a nominal type or generic type,
+      # even though in theory that would be possible.
+
+      # tuple
+      if left.is_a?(TupleType) && right.is_a?(TupleType)
+        # Tuples are immutable, so covariant subtyping allowed
+        return false unless left.params.length == right.params.length
+        return false unless left.params.zip(right.params).all? { |lt, rt| leq(lt, rt, inst, ileft) }
+        # subyping check passed
+        left.ubounds << right
+        right.lbounds << left
+        return true
+      end
+      if left.is_a?(TupleType) && right.is_a?(GenericType) && right.base == $__rdl_array_type
+        # TODO !ileft and right carries a free variable
+        return false unless left.promote!
+        return leq(left, right, inst, ileft) # recheck for promoted type
+      end
+
+      # finite hash
+      if left.is_a?(FiniteHashType) && right.is_a?(FiniteHashType)
+        # Like Tuples, FiniteHashes are immutable, so covariant subtyping allowed
+        # But note, no width subtyping allowed, to match #member?
+        rest = right.elts.clone # shallow copy
+        left.elts.each_pair { |k, tl|
+          return false unless rest.has_key? k
+          tr = rest[k]
+          tl = tl.type if tl.is_a? OptionalType
+          tr = tr.type if tr.is_a? OptionalType
+          return false unless leq(tl, tr, inst, ileft)
+          rest.delete k
+        }
+        rest.each_pair { |k, t|
+          return false unless t.is_a? OptionalType
+        }
+        left.ubounds << right
+        right.lbounds << left
+        return true
+      end
+      if left.is_a?(FiniteHashType) && right.is_a?(GenericType) && right.base == $__rdl_hash_type
+        # TODO !ileft and right carries a free variable
+        return false unless left.promote!
+        return leq(left, right, inst, ileft) # recheck for promoted type
+      end
+
+      return false
+    end
   end
+
+  # [+ a +] is an Array<Type> that may contain union types.
+  # returns Array<Array<Type>> containing all possible expansions of the union types.
+  # For example, slightly abusing notation:
+  #
+  # expand_product [A, B]           #=> [[A, B]]
+  # expand_product [A or B, C]      #=> [[A, C], [B, C]]
+  # expand_product [A or B, C or D] #=> [[A, C], [B, C], [A, D], [B, D]]
+  def self.expand_product(a)
+    return [[]] if a.empty? # logic below only applies if at least one element
+    a.map! { |t| t.canonical }
+    counts = a.map { |t| if t.is_a? UnionType then t.types.length - 1 else 0 end }
+    res = []
+    # now iterate through ever combination of indices
+    # using combinations is not quite as memory efficient as inlining that code here,
+    # but it's a lot easier to think about combinations separate from this code
+    combinations(counts).each { |inds|
+      tmp = []
+      # set tmp to be a with elts in positions in ind selected from unions
+      a.each_with_index { |t, i| if t.is_a? UnionType then tmp << t.types[inds[i]] else tmp << t end }
+      res << tmp
+    }
+    return res
+#    return [a]
+  end
+
+private
+
+  # [+ a +] is Array<Fixnum>
+  # returns Array<Array<Fixnum>> containing all combinations of 0..a[i] at index i
+  # For example:
+  #
+  # combinations [0, 0]  #=> [[0, 0]]
+  # combinations [1, 0]  #=> [[0, 0], [1, 0]]
+  # combinations [1, 1]  #=> [[0, 0], [0, 1][, [1, 0], [1, 1]]]
+  #
+  # yes, this is used in expand_product above!
+  def self.combinations(a)
+    cur = a.map { |x| 0 }
+    res = []
+    while ((cur <=> a) < 1) # Array#<=> uses lexicographic order, so this will repeat until cur == a
+      res << cur.dup
+      i = cur.length - 1 # start at right since want next in lexicographic order
+      while i >= 0
+        cur[i] += 1
+        break if (cur[i] <= a[i]) # increment did not overflow position, or it overflowed in position 0 so allow inc to break outer loop
+        cur[i] = 0 unless i == 0 # increment overflowed; reset to 0 and continue looping, except allow overflow to exit when i == 0
+        i -= 1
+      end
+    end
+    return res
+  end
+
 end

data/lib/rdl/types/union.rb

@@ -82,10 +82,20 @@ module RDL::Type
     end
 
     def <=(other)
+      return Type.leq(self, other)
+    end
+
+    def leq_inst(other, inst=nil, ileft=true)
       canonicalize!
-      return @canonical <= other if @canonical
+      return @canonical.leq_inst(other, inst, ileft) if @canonical
+      other = other.type if other.is_a? DependentArgType
       other = other.canonical
-      @types.all? { |t| t <= other }
+      if inst && !ileft && other.is_a?(VarType)
+        return leq_inst(inst[other.name], inst, ileft) if inst[other.name]
+        inst.merge!(other.name => self)
+        return true
+      end
+      return @types.all? { |t| t.leq_inst(other, inst, ileft) }
     end
 
     def member?(obj, *args)

data/lib/rdl/types/var.rb

@@ -32,7 +32,10 @@ module RDL::Type
 
     alias eql? ==
 
-    alias <= == # hack to allow rdl_query to work with union types...
+    # an uninstantiated variable is only comparable to itself
+    def <=(other)
+      return Type.leq(self, other)
+    end
 
     def match(other)
       other = other.canonical

data/lib/rdl/types/wild_query.rb

@@ -24,6 +24,7 @@ module RDL::Type
     alias eql? ==
 
     def <=(other)
+      other = other.type if other.is_a? DependentArgType
       other = other.canonical
       return self == other
     end

data/lib/rdl/wrap.rb

@@ -36,6 +36,7 @@ class RDL::Wrap
       # return if (klass.method_defined? meth_old) # now checked above by wrapped? call
       is_singleton_method = RDL::Util.has_singleton_marker(klass_str)
       full_method_name = RDL::Util.pp_klass_method(klass_str, meth)
+      klass_str_without_singleton = if is_singleton_method then RDL::Util.remove_singleton_marker(klass_str) else klass_str end
 
       klass.class_eval <<-RUBY, __FILE__, __LINE__
         alias_method meth_old, meth
@@ -59,18 +60,21 @@ class RDL::Wrap
             RDL::Contract::AndContract.check_array(pres, self, *args, &blk) if pres
             types = $__rdl_info.get(klass, meth, :type)
             if types
-              matches,args,blk,bind = RDL::Type::MethodType.check_arg_types("#{full_method_name}", self, bind, types, inst, *args, &blk)
+              matches, args, blk, bind = RDL::Type::MethodType.check_arg_types("#{full_method_name}", self, bind, types, inst, *args, &blk)
             end
           }
-	  ret = send(#{meth_old.inspect}, *args, &blk)
+	        ret = send(#{meth_old.inspect}, *args, &blk)
           $__rdl_wrap_switch.off {
             posts = $__rdl_info.get(klass, meth, :post)
             RDL::Contract::AndContract.check_array(posts, self, ret, *args, &blk) if posts
             if matches
               ret = RDL::Type::MethodType.check_ret_types(self, "#{full_method_name}", types, inst, matches, ret, bind, *args, &blk)
             end
+            if RDL::Config.instance.guess_types.include?("#{klass_str_without_singleton}".to_sym)
+              $__rdl_info.add(klass, meth, :otype, { args: (args.map { |arg| arg.class }), ret: ret.class, block: block_given? })
+            end
+            return ret
           }
-          return ret
         end
         if (public_method_defined? meth_old) then public meth
         elsif (protected_method_defined? meth_old) then protected meth
@@ -117,7 +121,7 @@ RUBY
   end
 
   # [+default_class+] should be a class
-  def self.process_type_args(default_class, *args, &blk)
+  def self.process_type_args(default_class, *args)
     klass = meth = type = nil
     default_class = "Object" if (default_class.is_a? Object) && (default_class.to_s == "main") # special case for main
     if args.size == 3
@@ -179,13 +183,13 @@ RUBY
   # 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
+      if sing
+        loc = the_self.singleton_method(meth).source_location
+      else
+        loc = the_self.instance_method(meth).source_location
+      end
       $__rdl_info.set(klass, meth, :source_location, loc)
       a = $__rdl_deferred
       $__rdl_deferred = [] # Reset before doing more work to avoid infinite recursion
@@ -195,10 +199,12 @@ RUBY
         else
           tmp_klass = klass
         end
-        raise RuntimeError, "Deferred contract from class #{prev_klass} being applied in class #{tmp_klass}" if prev_klass != tmp_klass
+        if (!h[:class_check] && (prev_klass != tmp_klass)) || (h[:class_check] && (h[:class_check].to_s != tmp_klass))
+          raise RuntimeError, "Deferred #{kind} contract from class #{prev_klass} being applied in class #{tmp_klass} to #{meth}"
+        end
         $__rdl_info.add(klass, meth, kind, contract)
         RDL::Wrap.wrap(klass, meth) if h[:wrap]
-        unless $__rdl_info.set(klass, meth, :typecheck, h[:typecheck])
+        unless !h.has_key?(:typecheck) || $__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
@@ -213,14 +219,24 @@ RUBY
     if $__rdl_to_wrap.member? [klass, meth]
       $__rdl_to_wrap.delete [klass, meth]
       RDL::Wrap.wrap(klass, meth)
+      if sing
+        loc = the_self.singleton_method(meth).source_location
+      else
+        loc = the_self.instance_method(meth).source_location
+      end
       $__rdl_info.set(klass, meth, :source_location, loc)
     end
 
-    # Type check method if requested; must typecheck before wrap
+    # Type check method if requested
     if $__rdl_to_typecheck[:now].member? [klass, meth]
       $__rdl_to_typecheck[:now].delete [klass, meth]
       RDL::Typecheck.typecheck(klass, meth)
     end
+
+    if RDL::Config.instance.guess_types.include?(the_self.to_s.to_sym) && !$__rdl_info.has?(klass, meth, :type)
+      # Added a method with no type annotation from a class we want to guess types for
+      RDL::Wrap.wrap(klass, meth)
+    end
   end
 end
 
@@ -238,41 +254,39 @@ class Object
   # pre(meth) { block } = pre(self, meth, FlatContract.new { block })
   # pre(contract) = pre(self, next method, contract)
   # pre { block } = pre(self, next method, FlatContract.new { block })
-  def pre(*args, wrap: true, &blk)
-    $__rdl_contract_switch.off { # Don't check contracts inside RDL code itself
-      klass, meth, contract = RDL::Wrap.process_pre_post_args(self, "Precondition", *args, &blk)
-      if meth
-        $__rdl_info.add(klass, meth, :pre, contract)
-        if wrap
-          if RDL::Util.method_defined?(klass, meth) || meth == :initialize # there is always an initialize
-            RDL::Wrap.wrap(klass, meth)
-          else
-            $__rdl_to_wrap << [klass, meth]
-          end
+  def pre(*args, wrap: RDL::Config.instance.pre_defaults[:wrap], &blk)
+    klass, meth, contract = RDL::Wrap.process_pre_post_args(self, "Precondition", *args, &blk)
+    if meth
+      $__rdl_info.add(klass, meth, :pre, contract)
+      if wrap
+        if RDL::Util.method_defined?(klass, meth) || meth == :initialize # there is always an initialize
+          RDL::Wrap.wrap(klass, meth)
+        else
+          $__rdl_to_wrap << [klass, meth]
         end
-      else
-        $__rdl_deferred << [klass, :pre, contract, {wrap: wrap}]
       end
-    }
+    else
+      $__rdl_deferred << [klass, :pre, contract, {wrap: wrap}]
+    end
+    nil
   end
 
   # Add a postcondition to a method. Same possible invocations as pre.
-  def post(*args, wrap: true, &blk)
-    $__rdl_contract_switch.off {
-      klass, meth, contract = RDL::Wrap.process_pre_post_args(self, "Postcondition", *args, &blk)
-      if meth
-        $__rdl_info.add(klass, meth, :post, contract)
-        if wrap
-          if RDL::Util.method_defined?(klass, meth) || meth == :initialize
-            RDL::Wrap.wrap(klass, meth)
-          else
-            $__rdl_to_wrap << [klass, meth]
-          end
+  def post(*args, wrap: RDL::Config.instance.post_defaults[:wrap], &blk)
+    klass, meth, contract = RDL::Wrap.process_pre_post_args(self, "Postcondition", *args, &blk)
+    if meth
+      $__rdl_info.add(klass, meth, :post, contract)
+      if wrap
+        if RDL::Util.method_defined?(klass, meth) || meth == :initialize
+          RDL::Wrap.wrap(klass, meth)
+        else
+          $__rdl_to_wrap << [klass, meth]
         end
-      else
-        $__rdl_deferred << [klass, :post, contract, {wrap: wrap}]
       end
-    }
+    else
+      $__rdl_deferred << [klass, :post, contract, {wrap: wrap}]
+    end
+    nil
   end
 
   # [+ klass +] may be Class, Symbol, or String
@@ -288,35 +302,35 @@ class Object
   # type(klass, meth, type)
   # type(meth, type)
   # type(type)
-  def type(*args, wrap: true, typecheck: false, &blk)
-    $__rdl_contract_switch.off {
-      klass, meth, type = begin
-                            RDL::Wrap.process_type_args(self, *args, &blk)
-                          rescue Racc::ParseError => err
-                            # Remove enough backtrace to only include actual source line
-                            # Warning: Adjust the -5 below if the code (or this comment) changes
-                            bt = err.backtrace
-                            bt.shift until bt[0] =~ /^#{__FILE__}:#{__LINE__-5}/
-                            bt.shift # remove $__rdl_contract_switch.off call
-                            bt.shift # remove type call itself
-                            err.set_backtrace bt
-                            raise err
-                          end
-      if meth
+  def type(*args, wrap: RDL::Config.instance.type_defaults[:wrap], typecheck: RDL::Config.instance.type_defaults[:typecheck])
+    klass, meth, type = begin
+                          RDL::Wrap.process_type_args(self, *args)
+                        rescue Racc::ParseError => err
+                          # Remove enough backtrace to only include actual source line
+                          # Warning: Adjust the -5 below if the code (or this comment) changes
+                          bt = err.backtrace
+                          bt.shift until bt[0] =~ /^#{__FILE__}:#{__LINE__-5}/
+                          bt.shift # remove $__rdl_contract_switch.off call
+                          bt.shift # remove type call itself
+                          err.set_backtrace bt
+                          raise err
+                        end
+    if meth
 # It turns out Ruby core/stdlib don't always follow this convention...
 #        if (meth.to_s[-1] == "?") && (type.ret != $__rdl_type_bool)
 #          warn "#{RDL::Util.pp_klass_method(klass, meth)}: methods that end in ? should have return type %bool"
 #        end
-        $__rdl_info.add(klass, meth, :type, type)
-        unless $__rdl_info.set(klass, meth, :typecheck, typecheck)
-          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_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_info.add(klass, meth, :type, type)
+      unless $__rdl_info.set(klass, meth, :typecheck, typecheck)
+        raise RuntimeError, "Inconsistent typecheck flag on #{RDL::Util.pp_klass_method(klass, meth)}"
+      end
+      if wrap || typecheck == :now
+        if RDL::Util.method_defined?(klass, meth) || meth == :initialize
+          $__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) if wrap
+        else
+          if wrap
             $__rdl_to_wrap << [klass, meth]
             if (typecheck && typecheck != :call)
               $__rdl_to_typecheck[typecheck] = Set.new unless $__rdl_to_typecheck[typecheck]
@@ -324,11 +338,12 @@ class Object
             end
           end
         end
-      else
-        $__rdl_deferred << [klass, :type, type, {wrap: wrap,
-                                                 typecheck: typecheck}]
       end
-    }
+    else
+      $__rdl_deferred << [klass, :type, type, {wrap: wrap,
+                                               typecheck: typecheck}]
+    end
+    nil
   end
 
   # [+ klass +] is the class containing the variable; self if omitted; ignored for local and global variables
@@ -342,6 +357,7 @@ class Object
     unless $__rdl_info.set(klass, var, :type, $__rdl_parser.scan_str("#T #{typ}"))
       raise RuntimeError, "Type already declared for #{var}"
     end
+    nil
   end
 
   # In the following three methods
@@ -355,6 +371,7 @@ class Object
       type name, "() -> #{typ}"
       type name.to_s + "=", "(#{typ}) -> #{typ}"
     }
+    nil
   end
 
   def attr_reader_type(*args)
@@ -363,6 +380,7 @@ class Object
       var_type ("@" + name.to_s), typ
       type name, "() -> #{typ}"
     }
+    nil
   end
 
   alias_method :attr_type, :attr_reader_type
@@ -373,46 +391,43 @@ class Object
       var_type ("@" + name.to_s), typ
       type name.to_s + "=", "(#{typ}) -> #{typ}"
     }
+    nil
   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)
-    }
+    klass = self.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    RDL::Wrap.do_method_added(self, false, klass, meth)
+    nil
   end
 
   def self.singleton_method_added(meth)
-    $__rdl_contract_switch.off {
-      klass = self.to_s
-      klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
-      sklass = RDL::Util.add_singleton_marker(klass)
-      RDL::Wrap.do_method_added(self, true, sklass, meth)
-    }
+    klass = self.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    sklass = RDL::Util.add_singleton_marker(klass)
+    RDL::Wrap.do_method_added(self, true, sklass, meth)
+    nil
   end
 
   # Aliases contracts for meth_old and meth_new. Currently, this must
   # be called for any aliases or they will not be wrapped with
   # contracts. Only creates aliases in the current class.
   def rdl_alias(new_name, old_name)
-    $__rdl_contract_switch.off {
-      klass = self.to_s
-      klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
-      $__rdl_aliases[klass] = {} unless $__rdl_aliases[klass]
-      if $__rdl_aliases[klass][new_name]
-        raise RuntimeError,
-              "Tried to alias #{new_name}, already aliased to #{$__rdl_aliases[klass][new_name]}"
-      end
-      $__rdl_aliases[klass][new_name] = old_name
+    klass = self.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    $__rdl_aliases[klass] = {} unless $__rdl_aliases[klass]
+    if $__rdl_aliases[klass][new_name]
+      raise RuntimeError,
+            "Tried to alias #{new_name}, already aliased to #{$__rdl_aliases[klass][new_name]}"
+    end
+    $__rdl_aliases[klass][new_name] = old_name
 
-      if self.method_defined? new_name
-        RDL::Wrap.wrap(klass, new_name)
-      else
-        $__rdl_to_wrap << [klass, old_name]
-      end
-    }
+    if self.method_defined? new_name
+      RDL::Wrap.wrap(klass, new_name)
+    else
+      $__rdl_to_wrap << [klass, old_name]
+    end
+    nil
   end
 
   # [+params+] is an array of symbols or strings that are the
@@ -428,85 +443,78 @@ class Object
   # parameters of the class, and the block should return true if and
   # only if self is a member of self.class<typs>.
   def type_params(params, all, variance: nil, &blk)
-    $__rdl_contract_switch.off {
-      raise RuntimeError, "Empty type parameters not allowed" if params.empty?
-      klass = self.to_s
-      klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
-      if $__rdl_type_params[klass]
-        raise RuntimeError, "#{klass} already has type parameters #{$__rdl_type_params[klass]}"
-      end
-      params = params.map { |v|
-        raise RuntimeError, "Type parameter #{v.inspect} is not symbol or string" unless v.class == String || v.class == Symbol
-        v.to_sym
-      }
-      raise RuntimeError, "Duplicate type parameters not allowed" unless params.uniq.size == params.size
-      raise RuntimeError, "Expecting #{params.size} variance annotations, got #{variance.size}" if variance && params.size != variance.size
-      raise RuntimeError, "Only :+, +-, and :~ are allowed variance annotations" unless (not variance) || variance.all? { |v| [:+, :-, :~].member? v }
-      raise RuntimeError, "Can't pass both all and a block" if all && blk
-      raise RuntimeError, "all must be a symbol" unless (not all) || (all.instance_of? Symbol)
-      chk = all || blk
-      raise RuntimeError, "At least one of {all, blk} required" unless chk
-      variance = params.map { |p| :~ } unless variance # default to invariant
-      $__rdl_type_params[klass] = [params, variance, chk]
+    raise RuntimeError, "Empty type parameters not allowed" if params.empty?
+    klass = self.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    if $__rdl_type_params[klass]
+      raise RuntimeError, "#{klass} already has type parameters #{$__rdl_type_params[klass]}"
+    end
+    params = params.map { |v|
+      raise RuntimeError, "Type parameter #{v.inspect} is not symbol or string" unless v.class == String || v.class == Symbol
+      v.to_sym
     }
+    raise RuntimeError, "Duplicate type parameters not allowed" unless params.uniq.size == params.size
+    raise RuntimeError, "Expecting #{params.size} variance annotations, got #{variance.size}" if variance && params.size != variance.size
+    raise RuntimeError, "Only :+, +-, and :~ are allowed variance annotations" unless (not variance) || variance.all? { |v| [:+, :-, :~].member? v }
+    raise RuntimeError, "Can't pass both all and a block" if all && blk
+    raise RuntimeError, "all must be a symbol" unless (not all) || (all.instance_of? Symbol)
+    chk = all || blk
+    raise RuntimeError, "At least one of {all, blk} required" unless chk
+    variance = params.map { |p| :~ } unless variance # default to invariant
+    $__rdl_type_params[klass] = [params, variance, chk]
+    nil
   end
 
   def rdl_nowrap
-    $__rdl_contract_switch.off {
-      RDL.config { |config| config.add_nowrap(self, self.singleton_class) }
-    }
+    RDL.config { |config| config.add_nowrap(self, self.singleton_class) }
+    nil
   end
 
   # [+typs+] is an array of types, classes, symbols, or strings to instantiate
   # the type parameters. If a class, symbol, or string is given, it is
   # converted to a NominalType.
   def instantiate!(*typs)
-    $__rdl_contract_switch.off {
-      klass = self.class.to_s
-      klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
-      formals, _, all = $__rdl_type_params[klass]
-      raise RuntimeError, "Receiver is of class #{klass}, which is not parameterized" unless formals
-      raise RuntimeError, "Expecting #{params.size} type parameters, got #{typs.size}" unless formals.size == typs.size
-      raise RuntimeError, "Instance already has type instantiation" if (defined? @__rdl_type) && @rdl_type
-      new_typs = typs.map { |t| if t.is_a? RDL::Type::Type then t else $__rdl_parser.scan_str "#T #{t}" end }
-      t = RDL::Type::GenericType.new(RDL::Type::NominalType.new(klass), *new_typs)
-      if all.instance_of? Symbol
-        self.send(all) { |*objs|
-          new_typs.zip(objs).each { |nt, obj|
-            if nt.instance_of? RDL::Type::GenericType # require obj to be instantiated
-              t_obj = RDL::Util.rdl_type(obj)
-              raise RDL::Type::TypeError, "Expecting element of type #{nt.to_s}, but got uninstantiated object #{obj.inspect}" unless t_obj
-              raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got type #{t_obj.to_s}" unless t_obj <= nt
-            else
-              raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got #{obj.inspect}" unless nt.member? obj
-            end
-          }
+    klass = self.class.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    formals, _, all = $__rdl_type_params[klass]
+    raise RuntimeError, "Receiver is of class #{klass}, which is not parameterized" unless formals
+    raise RuntimeError, "Expecting #{params.size} type parameters, got #{typs.size}" unless formals.size == typs.size
+    raise RuntimeError, "Instance already has type instantiation" if (defined? @__rdl_type) && @rdl_type
+    new_typs = typs.map { |t| if t.is_a? RDL::Type::Type then t else $__rdl_parser.scan_str "#T #{t}" end }
+    t = RDL::Type::GenericType.new(RDL::Type::NominalType.new(klass), *new_typs)
+    if all.instance_of? Symbol
+      self.send(all) { |*objs|
+        new_typs.zip(objs).each { |nt, obj|
+          if nt.instance_of? RDL::Type::GenericType # require obj to be instantiated
+            t_obj = RDL::Util.rdl_type(obj)
+            raise RDL::Type::TypeError, "Expecting element of type #{nt.to_s}, but got uninstantiated object #{obj.inspect}" unless t_obj
+            raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got type #{t_obj.to_s}" unless t_obj <= nt
+          else
+            raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got #{obj.inspect}" unless nt.member? obj
+          end
         }
-      else
-        raise RDL::Type::TypeError, "Not an instance of #{t}" unless instance_exec(*new_typs, &all)
-      end
-      @__rdl_type = t
-      self
-    }
+      }
+    else
+      raise RDL::Type::TypeError, "Not an instance of #{t}" unless instance_exec(*new_typs, &all)
+    end
+    @__rdl_type = t
+    self
   end
 
   def deinstantiate!
-    $__rdl_contract_switch.off {
-      raise RuntimeError, "Class #{self.to_s} is not parameterized" unless $__rdl_type_params[klass]
-      raise RuntimeError, "Instance is not instantiated" unless @__rdl_type && @@__rdl_type.instance_of?(RDL::Type::GenericType)
-      @__rdl_type = nil
-    }
+    raise RuntimeError, "Class #{self.to_s} is not parameterized" unless $__rdl_type_params[klass]
+    raise RuntimeError, "Instance is not instantiated" unless @__rdl_type && @@__rdl_type.instance_of?(RDL::Type::GenericType)
+    @__rdl_type = nil
+    self
   end
 
   # Returns a new object that wraps self in a type cast. If force is true this cast is *unchecked*, so use with caution
   def type_cast(typ, force: false)
-    $__rdl_contract_switch.off {
-      new_typ = if typ.is_a? RDL::Type::Type then typ else $__rdl_parser.scan_str "#T #{typ}" end
-      raise RuntimeError, "type cast error: self not a member of #{new_typ}" unless force || typ.member?(self)
-      obj = SimpleDelegator.new(self)
-      obj.instance_variable_set('@__rdl_type', new_typ)
-      return obj
-    }
+    new_typ = if typ.is_a? RDL::Type::Type then typ else $__rdl_parser.scan_str "#T #{typ}" end
+    raise RuntimeError, "type cast error: self not a member of #{new_typ}" unless force || typ.member?(self)
+    obj = SimpleDelegator.new(self)
+    obj.instance_variable_set('@__rdl_type', new_typ)
+    obj
   end
 
   # Add a new type alias.
@@ -514,18 +522,17 @@ class Object
   # [+typ+] can be either a string, in which case it will be parsed
   # into a type, or a Type.
   def type_alias(name, typ)
-    $__rdl_contract_switch.off {
-      raise RuntimeError, "Attempt to redefine type #{name}" if $__rdl_special_types[name]
-      case typ
-      when String
-        t = $__rdl_parser.scan_str "#T #{typ}"
-        $__rdl_special_types[name] = t
-      when RDL::Type::Type
-        $__rdl_special_types[name] = typ
-      else
-        raise RuntimeError, "Unexpected typ argument #{typ.inspect}"
-      end
-    }
+    raise RuntimeError, "Attempt to redefine type #{name}" if $__rdl_special_types[name]
+    case typ
+    when String
+      t = $__rdl_parser.scan_str "#T #{typ}"
+      $__rdl_special_types[name] = t
+    when RDL::Type::Type
+      $__rdl_special_types[name] = typ
+    else
+      raise RuntimeError, "Unexpected typ argument #{typ.inspect}"
+    end
+    nil
   end
 
   # Type check all methods that had annotation `typecheck: sym' at type call
@@ -534,6 +541,29 @@ class Object
       RDL::Typecheck.typecheck(klass, meth)
     }
     $__rdl_to_typecheck[sym] = Array.new
+    nil
+  end
+
+  # Does nothing at run time
+  def rdl_note_type(x)
+    return x
+  end
+
+  def rdl_remove_type(klass, meth)
+    raise RuntimeError, "No existing type for #{RDL::Util.pp_klass_method(klass, meth)}" unless $__rdl_info.has? klass, meth, :type
+    $__rdl_info.remove klass, meth, :type
+    nil
   end
 
 end
+
+# method_added for Object doesn't get called on module methods...bug?
+# class Module
+#   def method_added(meth)
+#     $__rdl_contract_switch.off {
+#       klass = self.to_s
+#       RDL::Wrap.do_method_added(self, false, klass, meth)
+#       nil
+#     }
+#   end
+# end