rdl 1.1.1 → 2.0.0.rc1

data/lib/rdl/types/wild_query.rb

@@ -1,5 +1,3 @@
-require_relative 'type_query'
-
 module RDL::Type
   class WildQuery < TypeQuery
     @@cache = nil
@@ -18,9 +16,18 @@ module RDL::Type
     end
 
     def ==(other)
+      return false if other.nil?
+      other = other.canonical
       return (other.instance_of? WildQuery)
     end
 
+    alias eql? ==
+
+    def <=(other)
+      other = other.canonical
+      return self == other
+    end
+
     def match(other)
       return true
     end

data/lib/rdl/util.rb

@@ -2,6 +2,7 @@ class RDL::Util
 
   SINGLETON_MARKER = "[s]"
   SINGLETON_MARKER_REGEXP = Regexp.escape(SINGLETON_MARKER)
+  GLOBAL_NAME = "_Globals" # something that's not a valid class name
 
   def self.to_class(klass)
     return klass if klass.class == Class
@@ -30,14 +31,15 @@ class RDL::Util
     return SINGLETON_MARKER + klass
   end
 
+  # Duplicate method...
   # Klass should be a string and may have a singleton marker
-  def self.pretty_name(klass, meth)
-    if klass =~ /^#{SINGLETON_MARKER_REGEXP}(.*)/
-      return "#{$1}.#{meth}"
-    else
-      return "#{klass}##{meth}"
-    end
-  end
+  # def self.pretty_name(klass, meth)
+  #   if klass =~ /^#{SINGLETON_MARKER_REGEXP}(.*)/
+  #     return "#{$1}.#{meth}"
+  #   else
+  #     return "#{klass}##{meth}"
+  #   end
+  # end
 
   def self.method_defined?(klass, method)
     begin

data/lib/rdl/wrap.rb

@@ -7,42 +7,14 @@ class RDL::Wrap
     klass = klass.to_s
     meth = meth.to_sym
     while $__rdl_aliases[klass] && $__rdl_aliases[klass][meth]
-      raise RuntimeError, "Alias #{klass}\##{meth} has contracts. Contracts are only allowed on methods, not aliases." if has_any_contracts?(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."
+      end
       meth = $__rdl_aliases[klass][meth]
     end
     return meth
   end
 
-  def self.add_contract(klass, meth, kind, val)
-    klass = klass.to_s
-    meth = meth.to_sym
-    $__rdl_contracts[klass] = {} unless $__rdl_contracts[klass]
-    $__rdl_contracts[klass][meth] = {} unless $__rdl_contracts[klass][meth]
-    $__rdl_contracts[klass][meth][kind] = [] unless $__rdl_contracts[klass][meth][kind]
-    $__rdl_contracts[klass][meth][kind] << val
-  end
-
-  def self.has_contracts?(klass, meth, kind)
-    klass = klass.to_s
-    meth = meth.to_sym
-    return ($__rdl_contracts.has_key? klass) &&
-           ($__rdl_contracts[klass].has_key? meth) &&
-           ($__rdl_contracts[klass][meth].has_key? kind)
-  end
-
-  def self.has_any_contracts?(klass, meth)
-    klass = klass.to_s
-    meth = meth.to_sym
-    return ($__rdl_contracts.has_key? klass) &&
-           ($__rdl_contracts[klass].has_key? meth)
-  end
-
-  def self.get_contracts(klass, meth, kind)
-    klass = klass.to_s
-    meth = meth.to_sym
-    return $__rdl_contracts[klass][meth][kind]
-  end
-
   def self.get_type_params(klass)
     klass = klass.to_s
     $__rdl_type_params[klass]
@@ -52,12 +24,13 @@ class RDL::Wrap
   # [+meth+] may be a String or Symbol
   #
   # Wraps klass#method to check contracts and types. Does not rewrap
-  # if already wrapped.
+  # if already wrapped. Also records source location of method.
   def self.wrap(klass_str, meth)
     $__rdl_wrap_switch.off {
       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::/
       meth_old = wrapped_name(klass, meth) # meth_old is a symbol
@@ -79,24 +52,21 @@ class RDL::Wrap
             inst = @__rdl_inst if defined? @__rdl_inst
             inst = Hash[$__rdl_type_params[klass][0].zip []] if (not(inst) && $__rdl_type_params[klass])
             inst = {} if not inst
-            #{if not(is_singleton_method) then "inst[:self] = RDL::Type::SingletonType.new(self)" end}
+            #{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})
-            if RDL::Wrap.has_contracts?(klass, meth, :pre)
-              pres = RDL::Wrap.get_contracts(klass, meth, :pre)
-              RDL::Contract::AndContract.check_array(pres, self, *args, &blk)
-            end
-            if RDL::Wrap.has_contracts?(klass, meth, :type)
-              types = RDL::Wrap.get_contracts(klass, meth, :type)
+            RDL::Typecheck.typecheck(klass, meth) if $__rdl_info.get(klass, meth, :typecheck)
+            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)
+            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 {
-            if RDL::Wrap.has_contracts?(klass, meth, :post)
-              posts = RDL::Wrap.get_contracts(klass, meth, :post)
-              RDL::Contract::AndContract.check_array(posts, self, ret, *args, &blk)
-            end
+            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
@@ -213,6 +183,7 @@ class Object
   # [+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)
   #
   # Add a precondition to a method. Possible invocations:
   # pre(klass, meth, contract)
@@ -221,35 +192,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, &blk)
+  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::Wrap.add_contract(klass, meth, :pre, contract)
-        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_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
         end
       else
-        $__rdl_deferred << [klass, :pre, contract]
+        $__rdl_deferred << [klass, :pre, contract, {wrap: wrap}]
       end
     }
   end
 
   # Add a postcondition to a method. Same possible invocations as pre.
-  def post(*args, &blk)
+  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::Wrap.add_contract(klass, meth, :post, contract)
-        if RDL::Util.method_defined?(klass, meth) || meth == :initialize
-          RDL::Wrap.wrap(klass, meth)
-        else
-          $__rdl_to_wrap << [klass, 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
         end
       else
-        $__rdl_deferred << [klass, :post, contract]
+        $__rdl_deferred << [klass, :post, contract, {wrap: wrap}]
       end
     }
   end
@@ -257,12 +232,14 @@ class Object
   # [+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)
   #
   # Set a method's type. Possible invocations:
   # type(klass, meth, type)
   # type(meth, type)
   # type(type)
-  def type(*args, &blk)
+  def type(*args, wrap: true, typecheck: false, typecheck_now: false, &blk)
     $__rdl_contract_switch.off {
       klass, meth, type = begin
                             RDL::Wrap.process_type_args(self, *args, &blk)
@@ -281,18 +258,37 @@ class Object
 #        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::Wrap.add_contract(klass, meth, :type, type)
-        if RDL::Util.method_defined?(klass, meth) || meth == :initialize
-          RDL::Wrap.wrap(klass, meth)
-        else
-          $__rdl_to_wrap << [klass, meth]
+        $__rdl_info.add(klass, meth, :type, type)
+        unless $__rdl_info.set(klass, meth, :typecheck, typecheck)
+          raise RuntimeError, "Inconsistent typecheck flag on #{klass}##{meth}"
+        end
+        if wrap
+          if RDL::Util.method_defined?(klass, meth) || meth == :initialize
+            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
+          end
         end
       else
-        $__rdl_deferred << [klass, :type, type]
+        $__rdl_deferred << [klass, :type, type, {wrap: wrap,
+                                                 typecheck: typecheck,
+                                                 typecheck_now: typecheck_now}]
       end
     }
   end
 
+  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
+    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
@@ -302,10 +298,15 @@ class Object
       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|
+        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::Wrap.add_contract(klass, meth, kind, contract)
-          RDL::Wrap.wrap(klass, meth)
+          $__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
+
 # 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"
@@ -318,6 +319,12 @@ class Object
         $__rdl_to_wrap.delete [klass, meth]
         RDL::Wrap.wrap(klass, meth)
       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
 
@@ -331,10 +338,14 @@ class Object
       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|
+        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::Wrap.add_contract(sklass, meth, kind, contract)
-          RDL::Wrap.wrap(sklass, meth)
+          $__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
 
@@ -343,6 +354,12 @@ class Object
         $__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
     }
   end
 
@@ -451,10 +468,11 @@ class Object
     }
   end
 
-  # Returns a new object that wraps self in a type cast. This cast is *unchecked*, so use with caution
-  def type_cast(typ)
+  # 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

data/lib/rdl_types.rb

@@ -1,4 +1,4 @@
 dir = RUBY_VERSION.split('.')[0] + ".x"
 
-require_rel "../types/ruby-#{dir}/_aliases.rb" # load type aliases first
-require_rel "../types/ruby-#{dir}/*.rb"
+require_relative "../types/ruby-#{dir}/_aliases.rb" # load type aliases first
+Dir[File.dirname(__FILE__) + "/../types/ruby-#{dir}/*.rb"].each { |f| require f }

data/rdl.gemspec

@@ -4,15 +4,13 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '1.1.1'
-  s.date        = '2016-05-21'
+  s.version     = '2.0.0.rc1'
+  s.date        = '2016-07-17'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
-RDL is a gem that allows contracts (pre- and postconditions) to be added to methods.
-Preconditions are checked at run time when the method is called, and
-postconditions are checked at run time when the method returns.
-RDL also includes extensive support for type contracts, which check the types of arguments and returns
-when the method is called and when it returns, respectively.
+RDL is a gem that adds types and contracts to Ruby. RDL includes extensive
+support for specifying method types, which can either be enforced as
+contracts or statically checked.
 EOF
   s.authors     = ['Jeffrey S. Foster', 'Brianna M. Ren', 'T. Stephen Strickland', 'Alexander T. Yu', 'Milod Kazerounian']
   s.email       = ['rdl-users@googlegroups.com']
@@ -20,5 +18,5 @@ EOF
   s.executables << 'rdl_query'
   s.homepage    = 'https://github.com/plum-umd/rdl'
   s.license     = 'BSD-3-Clause'
-  s.add_runtime_dependency 'require_all', '~> 1.3', '>= 1.3.3'
+  s.add_runtime_dependency 'parser', '~>2.3', '>= 2.3.1.2'
 end

data/test/test_alias.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestAlias < Minitest::Test
 
@@ -62,5 +63,5 @@ class TestAlias < Minitest::Test
     assert_equal 3, m10(3)
     assert_raises(RDL::Contract::ContractError) { m10(-1) }
   end
-  
-end
+
+end

data/test/test_contract.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestContract < Minitest::Test
   include RDL::Contract
@@ -26,7 +27,7 @@ class TestContract < Minitest::Test
     assert (posfivegt.check self, 5)
     assert_raises(ContractError) { posfivegt.check self, 4 }
   end
-  
+
   def test_or
     pos = FlatContract.new("Positive") { |x| x > 0 }
     zero = FlatContract.new("Zero") { |x| x == 0 }
@@ -58,7 +59,7 @@ class TestContract < Minitest::Test
     proc = pc.wrap(self) { |x, &blk| blk.call(x) }
     assert_equal 42, (proc.call(42) { |y| y })
   end
-  
+
   def test_turn_off
     foo = FlatContract.new("Foo") {
       pos = FlatContract.new("Positive") { |x| x > 0 }
@@ -67,4 +68,4 @@ class TestContract < Minitest::Test
     }
     assert_equal true, foo.check(self)
   end
-end
+end

data/test/test_dsl.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestDsl < Minitest::Test
 

data/test/test_generic.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestGeneric < Minitest::Test
 
@@ -32,22 +33,18 @@ class TestGeneric < Minitest::Test
       nil
     end
   end
-  
+
   def setup
     @ta = RDL::Type::NominalType.new "TestGeneric::A"
     @th = RDL::Type::NominalType.new "TestGeneric::H"
-    @tstring = RDL::Type::NominalType.new "String"
-    @tobject = RDL::Type::NominalType.new "Object"
-    @tfixnum = RDL::Type::NominalType.new "Fixnum"
-    @tas = RDL::Type::GenericType.new(@ta, @tstring)
-    @tao = RDL::Type::GenericType.new(@ta, @tobject)
+    @tas = RDL::Type::GenericType.new(@ta, $__rdl_string_type)
+    @tao = RDL::Type::GenericType.new(@ta, $__rdl_object_type)
     @taas = RDL::Type::GenericType.new(@ta, @tas)
     @taao = RDL::Type::GenericType.new(@ta, @tao)
-    @thss = RDL::Type::GenericType.new(@th, @tstring, @tstring)
-    @thoo = RDL::Type::GenericType.new(@th, @tobject, @tobject)
-    @thsf = RDL::Type::GenericType.new(@th, @tstring, @tfixnum)
+    @thss = RDL::Type::GenericType.new(@th, $__rdl_string_type, $__rdl_string_type)
+    @thoo = RDL::Type::GenericType.new(@th, $__rdl_object_type, $__rdl_object_type)
+    @thsf = RDL::Type::GenericType.new(@th, $__rdl_string_type, $__rdl_fixnum_type)
     @tb = RDL::Type::NominalType.new "TestGeneric::B"
-    @tnil = RDL::Type::NilType.new
   end
 
   def test_le
@@ -71,10 +68,10 @@ class TestGeneric < Minitest::Test
     assert (not (@thss <= @th))
 
     # Check co- and contravariance using B
-    tbss = RDL::Type::GenericType.new(@tb, @tstring, @tstring)
-    tbso = RDL::Type::GenericType.new(@tb, @tstring, @tobject)
-    tbos = RDL::Type::GenericType.new(@tb, @tobject, @tstring)
-    tboo = RDL::Type::GenericType.new(@tb, @tobject, @tobject)
+    tbss = RDL::Type::GenericType.new(@tb, $__rdl_string_type, $__rdl_string_type)
+    tbso = RDL::Type::GenericType.new(@tb, $__rdl_string_type, $__rdl_object_type)
+    tbos = RDL::Type::GenericType.new(@tb, $__rdl_object_type, $__rdl_string_type)
+    tboo = RDL::Type::GenericType.new(@tb, $__rdl_object_type, $__rdl_object_type)
     assert (tbss <= tbss)
     assert (not (tbss <= tbso))
     assert (tbss <= tbos)
@@ -94,10 +91,10 @@ class TestGeneric < Minitest::Test
   end
 
   def test_le_structural
-    tbss = RDL::Type::GenericType.new(@tb, @tstring, @tstring)
-    tma = RDL::Type::MethodType.new([], nil, @tnil)
-    tmb = RDL::Type::MethodType.new([@tstring], nil, @tnil)
-    tmc = RDL::Type::MethodType.new([@tfixnum], nil, @tnil)
+    tbss = RDL::Type::GenericType.new(@tb, $__rdl_string_type, $__rdl_string_type)
+    tma = RDL::Type::MethodType.new([], nil, $__rdl_nil_type)
+    tmb = RDL::Type::MethodType.new([$__rdl_string_type], nil, $__rdl_nil_type)
+    tmc = RDL::Type::MethodType.new([$__rdl_fixnum_type], nil, $__rdl_nil_type)
     ts1 = RDL::Type::StructuralType.new(m2: tma)
     assert (tbss <= ts1)
     ts2 = RDL::Type::StructuralType.new(m1: tmb)
@@ -109,18 +106,25 @@ class TestGeneric < Minitest::Test
     ts5 = RDL::Type::StructuralType.new(m1: tmb, m2: tmc)
     assert (tbss <= ts5)
   end
-  
+
   class C
     type "() -> self"
     def m1() return self; end
     type "() -> self"
     def m2() return C.new; end
+    type "() -> self"
+    def m3() return Object.new; end
   end
-  
+
+  class D < C
+  end
+
   def test_self_type
     c = C.new
     assert(c.m1)
-    assert_raises(RDL::Type::TypeError) { c.m2 }
+    assert(c.m2)
+    assert_raises(RDL::Type::TypeError) { c.m3 }
+    assert(D.new.m1)
   end
 
   def test_member
@@ -137,17 +141,17 @@ class TestGeneric < Minitest::Test
   end
 
   def test_instantiate
-    assert_raises(RuntimeError) { Object.new.instantiate!(@tstring) }
-    
+    assert_raises(RuntimeError) { Object.new.instantiate!($__rdl_string_type) }
+
     # Array<String>
     assert (A.new([]).instantiate!('String'))
-    assert (A.new(["a", "b", "c"]).instantiate!(@tstring))
+    assert (A.new(["a", "b", "c"]).instantiate!($__rdl_string_type))
     assert (A.new(["a", "b", "c"]).instantiate!('String'))
     assert_raises(RDL::Type::TypeError) { A.new([1, 2, 3]).instantiate!('String') }
 
     # Array<Object>
     assert (A.new([])).instantiate!('Object')
-    assert (A.new(["a", "b", "c"]).instantiate!(@tobject))
+    assert (A.new(["a", "b", "c"]).instantiate!($__rdl_object_type))
     assert (A.new(["a", "b", "c"]).instantiate!('Object'))
     assert (A.new([1, 2, 3]).instantiate!('Object'))