rdl 2.0.1 → 2.1.0

data/lib/rdl/types/structural.rb

@@ -59,6 +59,7 @@ module RDL::Type
       other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
+      return false unless other.instance_of? StructuralType
       return (@methods.length == other.methods.length &&
               @methods.all? { |k, v| (other.methods.has_key? k) && (v.match(other.methods[k]))})
     end

data/lib/rdl/types/tuple.rb

@@ -41,12 +41,12 @@ module RDL::Type
       other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
-      return @params.length == other.params.length && @params.zip(other.params).all? { |t,o| t.match(o) }
+      return (other.instance_of? TupleType) && (@params.length == other.params.length) && (@params.zip(other.params).all? { |t,o| t.match(o) })
     end
 
     def promote!
       return false if @cant_promote
-      @array = GenericType.new($__rdl_array_type, UnionType.new(*@params))
+      @array = GenericType.new(RDL::Globals.types[:array], UnionType.new(*@params))
       # note since we promoted this, lbounds and ubounds will be ignored in future constraints, which
       # is good because otherwise we'd get infinite loops
       return (@lbounds.all? { |lbound| lbound <= self }) && (@ubounds.all? { |ubound| self <= ubound })

data/lib/rdl/types/type.rb

@@ -75,7 +75,7 @@ module RDL::Type
       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)
+          types = RDL::Globals.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
@@ -94,7 +94,7 @@ module RDL::Type
 
       # generic
       if left.is_a?(GenericType) && right.is_a?(GenericType)
-        formals, variance, _ = $__rdl_type_params[left.base.name]
+        formals, variance, _ = RDL::Globals.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
@@ -115,13 +115,13 @@ module RDL::Type
       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]
+        formals, variance, _ = RDL::Globals.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)
+          types = RDL::Globals.info.get(klass, meth, :type)
           if types
             return false unless types.all? { |tlm| leq(tlm.instantiate(base_inst), t, nil, ileft) }
           end
@@ -166,7 +166,7 @@ module RDL::Type
         right.lbounds << left
         return true
       end
-      if left.is_a?(TupleType) && right.is_a?(GenericType) && right.base == $__rdl_array_type
+      if left.is_a?(TupleType) && right.is_a?(GenericType) && right.base == RDL::Globals.types[:array]
         # TODO !ileft and right carries a free variable
         return false unless left.promote!
         return leq(left, right, inst, ileft) # recheck for promoted type
@@ -200,7 +200,7 @@ module RDL::Type
         right.lbounds << left
         return true
       end
-      if left.is_a?(FiniteHashType) && right.is_a?(GenericType) && right.base == $__rdl_hash_type
+      if left.is_a?(FiniteHashType) && right.is_a?(GenericType) && right.base == RDL::Globals.types[:hash]
         # TODO !ileft and right carries a free variable
         return false unless left.promote!
         return leq(left, right, inst, ileft) # recheck for promoted type
@@ -237,8 +237,8 @@ module RDL::Type
 
 private
 
-  # [+ a +] is Array<Fixnum>
-  # returns Array<Array<Fixnum>> containing all combinations of 0..a[i] at index i
+  # [+ a +] is Array<Integer>
+  # returns Array<Array<Integer>> containing all combinations of 0..a[i] at index i
   # For example:
   #
   # combinations [0, 0]  #=> [[0, 0]]

data/lib/rdl/types/type_inferencer.rb

@@ -13,7 +13,7 @@ module RDL
       if current_types.size == 1
         current_types.to_a[0]
       elsif current_types.size == 0
-        $__rdl_nil_type
+        RDL::Globals.types[:nil]
       else
         RDL::Type::UnionType.new(*self.unify_param_types(current_types))
       end

data/lib/rdl/types/union.rb

@@ -7,7 +7,7 @@ module RDL::Type
     end
 
     def self.new(*types)
-      return $__rdl_nil_type if types.size == 0
+      return RDL::Globals.types[:bot] if types.size == 0
       ts = []
       # flatten nested unions, check that all args are types
       types.each { |t|
@@ -80,6 +80,7 @@ module RDL::Type
       other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
+      return false unless other.instance_of? UnionType
       return false if @types.length != other.types.length
       @types.all? { |t| other.types.any? { |ot| t.match(ot) } }
     end

data/lib/rdl/util.rb

@@ -15,6 +15,21 @@ class RDL::Util
     return c
   end
 
+  def self.singleton_class_to_class(cls)
+    cls_str = cls.to_s
+    cls_str = cls_str.split('(')[0] + '>' if cls_str['(']
+    to_class cls_str[8..-2]
+  end
+
+  def self.to_class_str(cls)
+    cls_str = cls.to_s
+    if cls_str.start_with? '#<Class:'
+      cls_str = cls_str.split('(')[0] + '>' if cls_str['(']
+      cls_str = RDL::Util.add_singleton_marker(cls_str[8..-2])
+    end
+    cls_str
+  end
+
   def self.has_singleton_marker(klass)
     return (klass =~ /^#{SINGLETON_MARKER_REGEXP}/)
   end
@@ -43,12 +58,22 @@ class RDL::Util
 
   def self.method_defined?(klass, method)
     begin
-      (self.to_class klass).method_defined?(method.to_sym) ||
-        (self.to_class klass).private_instance_methods.include?(method.to_sym) ||
-        (self.to_class klass).protected_instance_methods.include?(method.to_sym)
+      sk = self.to_class klass
+      msym = method.to_sym
+      mstr = method.to_s
+      sk.instance_method msym
     rescue NameError
       return false
     end
+    klass_str = RDL::Util.to_class_str(klass).hash
+    if mstr.start_with?('__rdl') and mstr.end_with?('_old_#{klass_str}')
+      mstr0 = RDL::Wrap.unwrapped_name(klass, mstr)
+      owner0 = sk.instance_method(mstr0).owner
+      owner = sk.instance_method(mstr).owner
+      return false if owner0 != owner
+    end
+
+    true
   end
 
   # Returns the @__rdl_type field of [+obj+]

data/lib/rdl/wrap.rb

@@ -6,18 +6,18 @@ class RDL::Wrap
   def self.resolve_alias(klass, meth)
     klass = klass.to_s
     meth = meth.to_sym
-    while $__rdl_aliases[klass] && $__rdl_aliases[klass][meth]
-      if $__rdl_info.has_any?(klass, meth, [:pre, :post, :type])
+    while RDL::Globals.aliases[klass] && RDL::Globals.aliases[klass][meth]
+      if RDL::Globals.info.has_any?(klass, meth, [:pre, :post, :type])
         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]
+      meth = RDL::Globals.aliases[klass][meth]
     end
     return meth
   end
 
   def self.get_type_params(klass)
     klass = klass.to_s
-    $__rdl_type_params[klass]
+    RDL::Globals.type_params[klass]
   end
 
   # [+klass+] may be a Class, String, or Symbol
@@ -26,11 +26,11 @@ class RDL::Wrap
   # Wraps klass#method to check contracts and types. Does not rewrap
   # if already wrapped. Also records source location of method.
   def self.wrap(klass_str, meth)
-    $__rdl_wrap_switch.off {
+    RDL::Globals.wrap_switch.off {
       klass_str = klass_str.to_s
       klass = RDL::Util.to_class klass_str
       return if wrapped? klass, meth
-      return if RDL::Config.instance.nowrap.member? klass
+      return if RDL::Config.instance.nowrap.member? klass_str.to_sym
       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
@@ -46,32 +46,32 @@ class RDL::Wrap
 	        bind = binding
           inst = nil
 
-          $__rdl_wrap_switch.off {
-            $__rdl_wrapped_calls["#{full_method_name}"] += 1 if RDL::Config.instance.gather_stats
+          RDL::Globals.wrap_switch.off {
+            RDL::Globals.wrapped_calls["#{full_method_name}"] += 1 if RDL::Config.instance.gather_stats
             inst = nil
-            inst = @__rdl_inst if defined? @__rdl_inst
-            inst = Hash[$__rdl_type_params[klass][0].zip []] if (not(inst) && $__rdl_type_params[klass])
+            inst = @__rdl_type.to_inst if ((defined? @__rdl_type) && @__rdl_type.is_a?(RDL::Type::GenericType))
+            inst = Hash[RDL::Globals.type_params[klass][0].zip []] if (not(inst) && RDL::Globals.type_params[klass])
             inst = {} if not inst
             #{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) == :call
-            pres = $__rdl_info.get(klass, meth, :pre)
+            RDL::Typecheck.typecheck(klass, meth) if RDL::Globals.info.get(klass, meth, :typecheck) == :call
+            pres = RDL::Globals.info.get(klass, meth, :pre)
             RDL::Contract::AndContract.check_array(pres, self, *args, &blk) if pres
-            types = $__rdl_info.get(klass, meth, :type)
+            types = RDL::Globals.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)
             end
           }
 	        ret = send(#{meth_old.inspect}, *args, &blk)
-          $__rdl_wrap_switch.off {
-            posts = $__rdl_info.get(klass, meth, :post)
+          RDL::Globals.wrap_switch.off {
+            posts = RDL::Globals.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? })
+              RDL::Globals.info.add(klass, meth, :otype, { args: (args.map { |arg| arg.class }), ret: ret.class, block: block_given? })
             end
             return ret
           }
@@ -112,7 +112,7 @@ RUBY
       klass = default_class.to_s
       contract = RDL::Contract::FlatContract.new(name, &blk)
     else
-      raise ArgumentError, "Invalid arguments"
+      raise ArgumentError, "Invalid arguments to `pre` or `post`"
     end
     raise ArgumentError, "#{contract.class} received where Contract expected" unless contract.class < RDL::Contract::Contract
 #    meth = :initialize if meth && meth.to_sym == :new  # actually wrap constructor
@@ -136,7 +136,7 @@ RUBY
       klass = default_class.to_s
       type = type_to_type args[0]
     else
-      raise ArgumentError, "Invalid arguments"
+      raise ArgumentError, "Invalid arguments to `type`"
     end
     raise ArgumentError, "Excepting method type, got #{type.class} instead" if type.class != RDL::Type::MethodType
 #    meth = :initialize if meth && slf && meth.to_sym == :new  # actually wrap constructor
@@ -147,12 +147,22 @@ RUBY
   private
 
   def self.wrapped_name(klass, meth)
-    "__rdl_#{meth.to_s}_old".to_sym
+    klass_str = RDL::Util.to_class_str(klass).hash
+    "__rdl_#{meth.to_s}_old_#{klass_str}".to_sym
+  end
+
+  def self.unwrapped_name(s)
+    if not s.start_with?('__rdl_') and s.include?('_old_')
+      raise Exception, "cannot get unwrapped name for #{s}"
+    end
+    klass_str = RDL::Util.to_class_str(klass).hash.to_s
+    s = klass_str.split("_#{klass_str}")
+    s[6..-5]
   end
 
   def self.class_to_string(klass)
     case klass
-    when Class
+    when Class, Module
       return klass.to_s
     when String
       return klass
@@ -176,7 +186,7 @@ RUBY
     when RDL::Type::Type
       return type
     when String
-      return $__rdl_parser.scan_str type
+      return RDL::Globals.parser.scan_str type
     end
   end
 
@@ -184,15 +194,15 @@ RUBY
   def self.do_method_added(the_self, sing, klass, meth)
     # Apply any deferred contracts and reset list
 
-    if $__rdl_deferred.size > 0
+    if RDL::Globals.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
+      RDL::Globals.info.set(klass, meth, :source_location, loc)
+      a = RDL::Globals.deferred
+      RDL::Globals.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)
@@ -202,50 +212,51 @@ RUBY
         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::Globals.info.add(klass, meth, kind, contract)
         RDL::Wrap.wrap(klass, meth) if h[:wrap]
-        unless !h.has_key?(:typecheck) || $__rdl_info.set(klass, meth, :typecheck, h[:typecheck])
+        unless !h.has_key?(:typecheck) || RDL::Globals.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])
+          RDL::Globals.to_typecheck[h[:typecheck]] = Set.new unless RDL::Globals.to_typecheck[h[:typecheck]]
+          RDL::Globals.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)
+    if RDL::Globals.to_wrap.member? [klass, meth]
+      RDL::Globals.to_wrap.delete [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)
+      RDL::Globals.info.set(klass, meth, :source_location, loc)
+      RDL::Wrap.wrap(klass, meth)
     end
 
     # Type check method if requested
-    if $__rdl_to_typecheck[:now].member? [klass, meth]
-      $__rdl_to_typecheck[:now].delete [klass, meth]
+    if RDL::Globals.to_typecheck[:now].member? [klass, meth]
+      RDL::Globals.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)
+    if RDL::Config.instance.guess_types.include?(the_self.to_s.to_sym) && !RDL::Globals.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
 
-class Object
-
+module RDL::Annotate
   # [+klass+] may be Class, Symbol, or String
   # [+method+] may be Symbol or String
   # [+contract+] must be a Contract
   # [+wrap+] indicates whether the contract should be enforced (true) or just recorded (false)
+  # [+ version +] is a rubygems version requirement string (or array of such requirement strings)
+  #    if the current Ruby version does not satisfy the version, the type call will be ignored
   #
   # Add a precondition to a method. Possible invocations:
   # pre(klass, meth, contract)
@@ -254,37 +265,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: RDL::Config.instance.pre_defaults[:wrap], &blk)
+  def pre(*args, wrap: RDL::Config.instance.pre_defaults[:wrap], version: nil, &blk)
+    return if version && !(Gem::Requirement.new(version).satisfied_by? Gem.ruby_version)
     klass, meth, contract = RDL::Wrap.process_pre_post_args(self, "Precondition", *args, &blk)
     if meth
-      $__rdl_info.add(klass, meth, :pre, contract)
+      RDL::Globals.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]
+          RDL::Globals.to_wrap << [klass, meth]
         end
       end
     else
-      $__rdl_deferred << [klass, :pre, contract, {wrap: wrap}]
+      RDL::Globals.deferred << [klass, :pre, contract, {wrap: wrap}]
     end
     nil
   end
 
   # Add a postcondition to a method. Same possible invocations as pre.
-  def post(*args, wrap: RDL::Config.instance.post_defaults[:wrap], &blk)
+  def post(*args, wrap: RDL::Config.instance.post_defaults[:wrap], version: nil, &blk)
+    return if version && !(Gem::Requirement.new(version).satisfied_by? Gem.ruby_version)
     klass, meth, contract = RDL::Wrap.process_pre_post_args(self, "Postcondition", *args, &blk)
     if meth
-      $__rdl_info.add(klass, meth, :post, contract)
+      RDL::Globals.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]
+          RDL::Globals.to_wrap << [klass, meth]
         end
       end
     else
-      $__rdl_deferred << [klass, :post, contract, {wrap: wrap}]
+      RDL::Globals.deferred << [klass, :post, contract, {wrap: wrap}]
     end
     nil
   end
@@ -297,12 +310,15 @@ class Object
   #    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
+  # [+ version +] is a rubygems version requirement string (or array of such requirement strings)
+  #    if the current Ruby version does not satisfy the version, the type call will be ignored
   #
   # Set a method's type. Possible invocations:
   # type(klass, meth, type)
   # type(meth, type)
   # type(type)
-  def type(*args, wrap: RDL::Config.instance.type_defaults[:wrap], typecheck: RDL::Config.instance.type_defaults[:typecheck])
+  def type(*args, wrap: RDL::Config.instance.type_defaults[:wrap], typecheck: RDL::Config.instance.type_defaults[:typecheck], version: nil)
+    return if version && !(Gem::Requirement.new(version).satisfied_by? Gem.ruby_version)
     klass, meth, type = begin
                           RDL::Wrap.process_type_args(self, *args)
                         rescue Racc::ParseError => err
@@ -310,37 +326,42 @@ class Object
                           # 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 RDL::Globals.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)
+#        if (meth.to_s[-1] == "?") && (type.ret != RDL::Globals.types[: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)
+      RDL::Globals.info.add(klass, meth, :type, type)
+      unless RDL::Globals.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 wrap || typecheck
         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::Globals.info.set(klass, meth, :source_location, RDL::Util.to_class(klass).instance_method(meth).source_location)
+          if typecheck == :now
+            RDL::Typecheck.typecheck(klass, meth)
+          elsif typecheck && (typecheck != :call)
+            RDL::Globals.to_typecheck[typecheck] = Set.new unless RDL::Globals.to_typecheck[typecheck]
+            RDL::Globals.to_typecheck[typecheck].add([klass, meth])
+          end
           RDL::Wrap.wrap(klass, meth) if wrap
         else
           if wrap
-            $__rdl_to_wrap << [klass, meth]
+            RDL::Globals.to_wrap << [klass, meth]
             if (typecheck && typecheck != :call)
-              $__rdl_to_typecheck[typecheck] = Set.new unless $__rdl_to_typecheck[typecheck]
-              $__rdl_to_typecheck[typecheck].add([klass, meth])
+              RDL::Globals.to_typecheck[typecheck] = Set.new unless RDL::Globals.to_typecheck[typecheck]
+              RDL::Globals.to_typecheck[typecheck].add([klass, meth])
             end
           end
         end
       end
     else
-      $__rdl_deferred << [klass, :type, type, {wrap: wrap,
+      RDL::Globals.deferred << [klass, :type, type, {wrap: wrap,
                                                typecheck: typecheck}]
     end
     nil
@@ -354,7 +375,7 @@ class Object
     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
     klass = RDL::Util::GLOBAL_NAME if var.to_s =~ /^\$/
-    unless $__rdl_info.set(klass, var, :type, $__rdl_parser.scan_str("#T #{typ}"))
+    unless RDL::Globals.info.set(klass, var, :type, RDL::Globals.parser.scan_str("#T #{typ}"))
       raise RuntimeError, "Type already declared for #{var}"
     end
     nil
@@ -394,42 +415,28 @@ class Object
     nil
   end
 
-  def self.method_added(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)
-    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)
-    klass = self.to_s
+  def rdl_alias(klass=self, new_name, old_name)
+    klass = klass.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]
+    RDL::Globals.aliases[klass] = {} unless RDL::Globals.aliases[klass]
+    if RDL::Globals.aliases[klass][new_name]
       raise RuntimeError,
-            "Tried to alias #{new_name}, already aliased to #{$__rdl_aliases[klass][new_name]}"
+            "Tried to alias #{new_name}, already aliased to #{RDL::Globals.aliases[klass][new_name]}"
     end
-    $__rdl_aliases[klass][new_name] = old_name
+    RDL::Globals.aliases[klass][new_name] = old_name
 
-    if self.method_defined? new_name
+    if Module.const_defined?(klass) && RDL::Util.to_class(klass).method_defined?(new_name)
       RDL::Wrap.wrap(klass, new_name)
     else
-      $__rdl_to_wrap << [klass, old_name]
+      RDL::Globals.to_wrap << [klass, old_name]
     end
     nil
   end
 
+  # [+ klass +] is the class whose type parameters to set; self if omitted
   # [+params+] is an array of symbols or strings that are the
   # parameters of this (generic) type
   # [+variance+] is an array of the corresponding variances, :+ for
@@ -442,12 +449,12 @@ class Object
   # block will be passed an array typs corresponding to the type
   # 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)
+  def type_params(klass=self, params, all, variance: nil, &blk)
     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]}"
+    klass = klass.to_s
+    if RDL::Globals.type_params[klass]
+      raise RuntimeError, "#{klass} already has type parameters #{RDL::Globals.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
@@ -461,123 +468,167 @@ class Object
     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.config { |config| config.add_nowrap(self, self.singleton_class) }
+    RDL::Globals.type_params[klass] = [params, variance, chk]
     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)
-    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
-  end
+  # The following code attempts to warn about annotation methods already being defined on the class/module.
+  # But it doesn't work because `extended` gets called *after* the module's methods are already added...
+  # def self.extended(other)
+  #   [:pre,
+  #    :post,
+  #    :type,
+  #    :var_type,
+  #    :attr_accessor_type,
+  #    :attr_reader_type,
+  #    :attr_type,
+  #    :attr_writer_type,
+  #    :rdl_alias,
+  #    :type_params].each { |a|
+  #      warn "RDL WARNING: #{other.to_s} extended RDL::Annotate but already has #{a} defined" if other.respond_to? a
+  #    }
+  # end
+end
 
-  def deinstantiate!
-    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
+# all methods in RDL::Annotate but with an `rdl_` prefix
+module RDL::RDLAnnotate
+  define_method :rdl_pre, RDL::Annotate.instance_method(:pre)
+  define_method :rdl_post, RDL::Annotate.instance_method(:post)
+  define_method :rdl_type, RDL::Annotate.instance_method(:type)
+  define_method :rdl_var_type, RDL::Annotate.instance_method(:var_type)
+  define_method :rdl_attr_accessor_type, RDL::Annotate.instance_method(:attr_accessor_type)
+  define_method :rdl_attr_reader_type, RDL::Annotate.instance_method(:attr_reader_type)
+  define_method :rdl_attr_type, RDL::Annotate.instance_method(:attr_type)
+  define_method :rdl_attr_writer_type, RDL::Annotate.instance_method(:attr_writer_type)
+  define_method :rdl_alias, RDL::Annotate.instance_method(:rdl_alias)
+  define_method :rdl_type_params, RDL::Annotate.instance_method(:type_params)
+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)
-    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
+module RDL
+  extend RDL::Annotate
 
   # Add a new type alias.
   # [+name+] must be a string beginning with %.
   # [+typ+] can be either a string, in which case it will be parsed
   # into a type, or a Type.
-  def type_alias(name, typ)
-    raise RuntimeError, "Attempt to redefine type #{name}" if $__rdl_special_types[name]
+  def self.type_alias(name, typ)
+    raise RuntimeError, "Attempt to redefine type #{name}" if RDL::Globals.special_types[name]
     case typ
     when String
-      t = $__rdl_parser.scan_str "#T #{typ}"
-      $__rdl_special_types[name] = t
+      t = RDL::Globals.parser.scan_str "#T #{typ}"
+      RDL::Globals.special_types[name] = t
     when RDL::Type::Type
-      $__rdl_special_types[name] = typ
+      RDL::Globals.special_types[name] = typ
     else
       raise RuntimeError, "Unexpected typ argument #{typ.inspect}"
     end
     nil
   end
 
+  def self.nowrap(klass=self)
+    RDL.config { |config| config.add_nowrap(klass) }
+    nil
+  end
+
   # Register [+ blk +] to be executed when `rdl_do_typecheck [+ sym +]` is called.
   # The blk will be called with sym as its argument. The order
   # in which multiple blks for the same sym will be executed is unspecified
-  def rdl_at(sym, &blk)
-    $__rdl_at[sym] = [] unless $__rdl_at[sym]
-    $__rdl_at[sym] << blk
+  def self.at(sym, &blk)
+    RDL::Globals.to_do_at[sym] = [] unless RDL::Globals.to_do_at[sym]
+    RDL::Globals.to_do_at[sym] << blk
   end
 
   # Invokes all callbacks from rdl_at(sym), in unspecified order.
   # Afterwards, type checks all methods that had annotation `typecheck: sym' at type call, in unspecified order.
-  def rdl_do_typecheck(sym)
-    if $__rdl_at[sym]
-      $__rdl_at[sym].each { |blk| blk.call(sym) }
+  def self.do_typecheck(sym)
+    if RDL::Globals.to_do_at[sym]
+      RDL::Globals.to_do_at[sym].each { |blk| blk.call(sym) }
     end
-    $__rdl_at[sym] = Array.new
-    return unless $__rdl_to_typecheck[sym]
-    $__rdl_to_typecheck[sym].each { |klass, meth|
+    RDL::Globals.to_do_at[sym] = Array.new
+    return unless RDL::Globals.to_typecheck[sym]
+    RDL::Globals.to_typecheck[sym].each { |klass, meth|
       RDL::Typecheck.typecheck(klass, meth)
     }
-    $__rdl_to_typecheck[sym] = Set.new
+    RDL::Globals.to_typecheck[sym] = Set.new
     nil
   end
 
   # Does nothing at run time
-  def rdl_note_type(x)
+  def self.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
+  def self.remove_type(klass, meth)
+    raise RuntimeError, "No existing type for #{RDL::Util.pp_klass_method(klass, meth)}" unless RDL::Globals.info.has? klass, meth, :type
+    RDL::Globals.info.remove klass, meth, :type
     nil
   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 self.type_cast(obj, typ, force: false)
+    new_typ = if typ.is_a? RDL::Type::Type then typ else RDL::Globals.parser.scan_str "#T #{typ}" end
+    raise RuntimeError, "type cast error: self not a member of #{new_typ}" unless force || typ.member?(obj)
+    new_obj = SimpleDelegator.new(obj)
+    new_obj.instance_variable_set('@__rdl_type', new_typ)
+    new_obj
+  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 self.instantiate!(obj, *typs, check: false)
+    klass = obj.class.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    formals, _, all = RDL::Globals.type_params[klass]
+    raise RuntimeError, "Receiver is of class #{klass}, which is not parameterized" unless formals
+    raise RuntimeError, "Expecting #{formals.size} type parameters, got #{typs.size}" unless formals.size == typs.size
+    raise RuntimeError, "Instance already has type instantiation" if obj.instance_variable_get(:@__rdl_type)
+    new_typs = typs.map { |t| if t.is_a? RDL::Type::Type then t else RDL::Globals.parser.scan_str "#T #{t}" end }
+    t = RDL::Type::GenericType.new(RDL::Type::NominalType.new(klass), *new_typs)
+    if check
+      if all.instance_of? Symbol
+        obj.send(all) { |*objs|
+          new_typs.zip(objs).each { |nt, o|
+            if nt.instance_of? RDL::Type::GenericType # require o to be instantiated
+              t_o = RDL::Util.rdl_type(o)
+              raise RDL::Type::TypeError, "Expecting element of type #{nt.to_s}, but got uninstantiated object #{o.inspect}" unless t_o
+              raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got type #{t_o.to_s}" unless t_o <= nt
+            else
+              raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got #{o.inspect}" unless nt.member? o
+            end
+          }
+        }
+      else
+        raise RDL::Type::TypeError, "Not an instance of #{t}" unless instance_exec(*new_typs, &all)
+      end
+    end
+    obj.instance_variable_set(:@__rdl_type, t)
+    obj
+  end
+
+  def self.deinstantiate!(obj)
+    klass = obj.class.to_s
+    klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
+    raise RuntimeError, "Class #{self.to_s} is not parameterized" unless RDL::Globals.type_params[klass]
+    raise RuntimeError, "Instance is not instantiated" unless obj.instance_variable_get(:@__rdl_type).instance_of?(RDL::Type::GenericType)
+    obj.instance_variable_set(:@__rdl_type, nil)
+    obj
+  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
+class Module
+  def method_added(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 singleton_method_added(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
+end