Rename the VM internal 'var' type to 'Dynamic' type.

runtime/vm/object.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 30 matching lines @@
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 RawObject* Object::null_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::sentinel_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::transition_sentinel_ =
     reinterpret_cast<RawInstance*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::var_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::parameterized_type_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_array_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 14 matching lines @@
 RawClass* Object::context_scope_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::api_failure_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 #undef RAW_NULL
 
 int Object::GetSingletonClassIndex(const RawClass* raw_class) {
   ASSERT(raw_class->IsHeapObject());
   if (raw_class == class_class()) {
     return kClassClass;
   } else if (raw_class == null_class()) {
     return kNullClass;
-  } else if (raw_class == var_class()) {
-    return kVarClass;
+  } else if (raw_class == dynamic_class()) {
+    return kDynamicClass;
   } else if (raw_class == void_class()) {
     return kVoidClass;
   } else if (raw_class == unresolved_class_class()) {
     return kUnresolvedClassClass;
   } else if (raw_class == parameterized_type_class()) {
     return kParameterizedTypeClass;
   } else if (raw_class == type_parameter_class()) {
     return kTypeParameterClass;
   } else if (raw_class == instantiated_type_class()) {
     return kInstantiatedTypeClass;
@@ skipping 31 matching lines @@
     return kApiFailureClass;
   }
   return kInvalidIndex;
 }
 
 
 RawClass* Object::GetSingletonClass(int index) {
   switch (index) {
     case kClassClass: return class_class();
     case kNullClass: return null_class();
-    case kVarClass: return var_class();
+    case kDynamicClass: return dynamic_class();
     case kVoidClass: return void_class();
     case kUnresolvedClassClass: return unresolved_class_class();
     case kParameterizedTypeClass: return parameterized_type_class();
     case kTypeParameterClass: return type_parameter_class();
     case kInstantiatedTypeClass: return instantiated_type_class();
     case kTypeArgumentsClass: return type_arguments_class();
     case kTypeArrayClass: return type_array_class();
     case kInstantiatedTypeArgumentsClass:
         return instantiated_type_arguments_class();
     case kFunctionClass: return function_class();
@@ skipping 13 matching lines @@
   }
   UNREACHABLE();
   return reinterpret_cast<RawClass*>(kHeapObjectTag);  // return RAW_NULL.
 }
 
 
 const char* Object::GetSingletonClassName(int index) {
   switch (index) {
     case kClassClass: return "Class";
     case kNullClass: return "Null";
-    case kVarClass: return "var";
+    case kDynamicClass: return "Dynamic";
     case kVoidClass: return "void";
     case kUnresolvedClassClass: return "UnresolvedClass";
     case kParameterizedTypeClass: return "ParameterizedType";
     case kTypeParameterClass: return "TypeParameter";
     case kInstantiatedTypeClass: return "InstantiatedType";
     case kTypeArgumentsClass: return "TypeArguments";
     case kTypeArrayClass: return "TypeArray";
     case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
     case kFunctionClass: return "Function";
     case kFieldClass: return "Field";
@@ skipping 72 matching lines @@
     transition_sentinel ^=
         Object::Allocate(cls, Instance::InstanceSize(), Heap::kOld);
     transition_sentinel_ = transition_sentinel.raw();
   }
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
   cls = Class::New<Instance>();
-  var_class_ = cls.raw();
+  dynamic_class_ = cls.raw();
 
   cls = Class::New<Instance>();
   void_class_ = cls.raw();
 
   cls = Class::New<ParameterizedType>();
   parameterized_type_class_ = cls.raw();
 
   cls = Class::New<TypeParameter>();
   type_parameter_class_ = cls.raw();
 
@@ skipping 273 matching lines @@
   core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_interface(type);
 
   name = String::NewSymbol("bool");
   cls = Class::NewInterface(name, script);
   core_lib.AddClass(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_interface(type);
 
-  // The classes 'null', 'var', and 'void' are not registered in the class
+  // The classes 'Null', 'Dynamic', and 'void' are not registered in the class
   // dictionary and are not named, but corresponding types are stored in the
   // object store.
   cls = null_class_;
   type = Type::NewNonParameterizedType(cls);
   object_store->set_null_type(type);
 
-  cls = var_class_;
+  cls = dynamic_class_;
   type = Type::NewNonParameterizedType(cls);
-  object_store->set_var_type(type);
+  object_store->set_dynamic_type(type);
 
   cls = void_class_;
   type = Type::NewNonParameterizedType(cls);
   object_store->set_void_type(type);
 
   // Finish the initialization by compiling the bootstrap script containing the
   // implementation of the internal classes.
   Bootstrap::Compile(Library::Handle(Library::CoreLibrary()), script);
   Bootstrap::Compile(Library::Handle(Library::CoreImplLibrary()), impl_script);
 
@@ skipping 627 matching lines @@
 bool Class::IsCanonicalSignatureClass() const {
   const Function& function = Function::Handle(signature_function());
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
 
 bool Class::IsMoreSpecificThan(
     const TypeArguments& type_arguments,
     const Class& other,
     const TypeArguments& other_type_arguments) const {
-  // Check for VarType.
-  // The VarType on the lefthand side is replaced by the bottom type, which is
-  // more specific than any type.
-  // Any type is more specific than the VarType on the righthand side.
-  if (IsVarClass() || other.IsVarClass()) {
+  // Check for DynamicType.
+  // The DynamicType on the lefthand side is replaced by the bottom type, which
+  // is more specific than any type.
+  // Any type is more specific than the DynamicType on the righthand side.
+  if (IsDynamicClass() || other.IsDynamicClass()) {
     return true;
   }
   // Check for reflexivity.
   if (raw() == other.raw()) {
     const intptr_t len = NumTypeArguments();
     if (len == 0) {
       return true;
     }
     // Since we do not truncate the type argument vector of a subclass (see
     // below), we only check a prefix of the proper length.
     // Check for covariance.
     if (type_arguments.IsNull() ||
         other_type_arguments.IsNull() ||
-        type_arguments.IsVarTypes(len) ||
-        other_type_arguments.IsVarTypes(len)) {
+        type_arguments.IsDynamicTypes(len) ||
+        other_type_arguments.IsDynamicTypes(len)) {
       return true;
     }
     return type_arguments.IsMoreSpecificThan(other_type_arguments, len);
   }
   // Check for two function types.
   if (IsSignatureClass() && other.IsSignatureClass()) {
     const Function& fun = Function::Handle(signature_function());
     const Function& other_fun = Function::Handle(other.signature_function());
     return fun.IsSubtypeOf(type_arguments,
                            other_fun,
@@ skipping 21 matching lines @@
           // interface.
           interface_args = TypeArguments::null();
         } else {
           // The type arguments of this type that are referred to by the type
           // parameters of the interface are at the end of the type vector,
           // after the type arguments of the super type of this type.
           const intptr_t offset = NumTypeArguments() - NumTypeParameters();
           interface_args = interface_args.InstantiateFrom(type_arguments,
                                                           offset);
           // TODO(regis): Check the subtyping constraints if any, i.e. if
-          // interface.type_parameter_extends() is not an array of VarType.
+          // interface.type_parameter_extends() is not an array of DynamicType.
           // Should we pass the constraints to InstantiateFrom and it would
           // return null on failure?
         }
       }
       if (interface_class.IsMoreSpecificThan(interface_args,
                                              other,
                                              other_type_arguments)) {
         return true;
       }
     }
   }
   // Check the interface case.
   if (is_interface()) {
     // We already checked the case where 'other' is an interface. Now, 'this',
     // an interface, cannot be more specific than a class, except class Object,
     // because although Object is not considered an interface by the vm, it is
     // one. In other words, all classes implementing this interface also extend
-    // class Object. An interface is also more specific than the VarType.
-    return (other.IsVarClass() || other.IsObjectClass());
+    // class Object. An interface is also more specific than the DynamicType.
+    return (other.IsDynamicClass() || other.IsObjectClass());
   }
   const Class& super_class = Class::Handle(SuperClass());
   if (super_class.IsNull()) {
     return false;
   }
   // Instead of truncating the type argument vector to the length of the super
   // type argument vector, we make sure that the code works with a vector that
   // is longer than necessary.
   return super_class.IsMoreSpecificThan(type_arguments,
                                         other,
@@ skipping 345 matching lines @@
   String& class_name = String::Handle();
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
     class_name = cls.Name();
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
     if (num_type_params > num_args) {
       first_type_param_index = 0;
       if (IsBeingFinalized()) {
-        // Most probably an illformed type. Do not fill up with "var".
+        // Most probably an illformed type. Do not fill up with "Dynamic".
         num_type_params = num_args;
       } else {
         ASSERT(num_args == 0);  // Type is raw.
-        // We fill up with "var".
+        // We fill up with "Dynamic".
       }
     } else {
       first_type_param_index = num_args - num_type_params;
     }
     if (cls.IsSignatureClass()) {
       // We may be reporting an error about an illformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
       if (IsBeingFinalized()) {
         return class_name.raw();
       }
@@ skipping 14 matching lines @@
   } else {
     const intptr_t num_strings = 2*num_type_params + 2;  // "C""<""T"", ""T"">".
     const Array& strings = Array::Handle(Array::New(num_strings));
     intptr_t s = 0;
     strings.SetAt(s++, class_name);
     strings.SetAt(s++, String::Handle(String::NewSymbol("<")));
     const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
     Type& type = Type::Handle();
     for (intptr_t i = 0; i < num_type_params; i++) {
       if (first_type_param_index + i >= num_args) {
-        type = VarType();
+        type = DynamicType();
       } else {
         type = args.TypeAt(first_type_param_index + i);
       }
       type_name = type.Name();
       strings.SetAt(s++, type_name);
       if (i < num_type_params - 1) {
         strings.SetAt(s++, kCommaSpace);
       }
     }
     strings.SetAt(s++, String::Handle(String::NewSymbol(">")));
@@ skipping 94 matching lines @@
                               TypeArguments::Handle(other.arguments()));
   }
 }
 
 
 RawType* Type::NullType() {
   return Isolate::Current()->object_store()->null_type();
 }
 
 
-RawType* Type::VarType() {
-  return Isolate::Current()->object_store()->var_type();
+RawType* Type::DynamicType() {
+  return Isolate::Current()->object_store()->dynamic_type();
 }
 
 
 RawType* Type::VoidType() {
   return Isolate::Current()->object_store()->void_type();
 }
 
 
 RawType* Type::ObjectType() {
   return Isolate::Current()->object_store()->object_type();
@@ skipping 204 matching lines @@
 void TypeParameter::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 RawType* TypeParameter::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   if (instantiator_type_arguments.IsNull()) {
-    return VarType();
+    return DynamicType();
   }
   return instantiator_type_arguments.TypeAt(Index() + offset);
 }
 
 
 RawTypeParameter* TypeParameter::New() {
   const Class& type_parameter_class =
       Class::Handle(Object::type_parameter_class());
   RawObject* raw = Object::Allocate(type_parameter_class,
                                     TypeParameter::InstanceSize(),
@@ skipping 107 matching lines @@
 
 RawTypeArguments* TypeArguments::InstantiateFrom(
     const TypeArguments& instantiator_type_arguments,
     intptr_t offset) const {
   // TypeArguments is an abstract class.
   UNREACHABLE();
   return TypeArguments::null();
 }
 
 
-bool TypeArguments::IsVarTypes(intptr_t len) const {
+bool TypeArguments::IsDynamicTypes(intptr_t len) const {
   ASSERT(Length() >= len);
   Type& type = Type::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     if (!type.HasResolvedTypeClass()) {
       ASSERT(type.IsTypeParameter());
       return false;
     }
     type_class = type.type_class();
-    if (!type_class.IsVarClass()) {
+    if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsMoreSpecificThan(const TypeArguments& other,
                                        intptr_t len) const {
   ASSERT(Length() >= len);
@@ skipping 527 matching lines @@
   if ((num_fixed_params != other_num_fixed_params) ||
       ((test == Type::kIsSubtypeOf) &&
        (num_opt_params < other_num_opt_params))) {
     return false;
   }
   // Check the result type.
   Type& other_res_type = Type::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
     other_res_type = other_res_type.InstantiateFrom(other_type_arguments, 0);
   }
-  if (!other_res_type.IsVarType() && !other_res_type.IsVoidType()) {
+  if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
     Type& res_type = Type::Handle(result_type());
     if (!res_type.IsInstantiated()) {
       res_type = res_type.InstantiateFrom(type_arguments, 0);
     }
-    if (!res_type.IsVarType() &&
+    if (!res_type.IsDynamicType() &&
         (res_type.IsVoidType() || !res_type.IsAssignableTo(other_res_type))) {
       return false;
     }
   }
   // Check the types of fixed parameters.
   Type& param_type = Type::Handle();
   Type& other_param_type = Type::Handle();
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     param_type = ParameterTypeAt(i);
     if (!param_type.IsInstantiated()) {
       param_type = param_type.InstantiateFrom(type_arguments, 0);
     }
-    if (param_type.IsVarType()) {
+    if (param_type.IsDynamicType()) {
       continue;
     }
     other_param_type = other.ParameterTypeAt(i);
     if (!other_param_type.IsInstantiated()) {
       other_param_type =
           other_param_type.InstantiateFrom(other_type_arguments, 0);
     }
-    if (other_param_type.IsVarType()) {
+    if (other_param_type.IsDynamicType()) {
       continue;
     }
     // Subtyping and assignability rules are identical when applied to parameter
     // types.
     ASSERT((test == Type::kIsSubtypeOf) || (test == Type::kIsAssignableTo));
     if (!param_type.IsSubtypeOf(other_param_type) &&
         !other_param_type.IsSubtypeOf(param_type)) {
       return false;
     }
   }
@@ skipping 12 matching lines @@
   for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     found_param_name = false;
     for (intptr_t j = num_fixed_params; j < num_params; j++) {
       if (ParameterNameAt(j) == other_param_name.raw()) {
         found_param_name = true;
         param_type = ParameterTypeAt(j);
         if (!param_type.IsInstantiated()) {
           param_type = param_type.InstantiateFrom(type_arguments, 0);
         }
-        if (param_type.IsVarType()) {
+        if (param_type.IsDynamicType()) {
           break;
         }
         other_param_type = other.ParameterTypeAt(i);
         if (!other_param_type.IsInstantiated()) {
           other_param_type =
               other_param_type.InstantiateFrom(other_type_arguments, 0);
         }
-        if (other_param_type.IsVarType()) {
+        if (other_param_type.IsDynamicType()) {
           break;
         }
         if (!param_type.IsSubtypeOf(other_param_type) &&
             !other_param_type.IsSubtypeOf(param_type)) {
           is_subtype = false;
         }
         break;
       }
     }
     if (!found_param_name) {
@@ skipping 20 matching lines @@
     param_name = ParameterNameAt(i);
     found_param_name = false;
     for (intptr_t j = other_num_fixed_params; j < other_num_params; j++) {
       if (other.ParameterNameAt(j) == param_name.raw()) {
         found_param_name = true;
         other_param_type = other.ParameterTypeAt(j);
         if (!other_param_type.IsInstantiated()) {
           other_param_type =
               other_param_type.InstantiateFrom(other_type_arguments, 0);
         }
-        if (other_param_type.IsVarType()) {
+        if (other_param_type.IsDynamicType()) {
           break;
         }
         param_type = ParameterTypeAt(i);
         if (!param_type.IsInstantiated()) {
           param_type = param_type.InstantiateFrom(type_arguments, 0);
         }
-        if (param_type.IsVarType()) {
+        if (param_type.IsDynamicType()) {
           break;
         }
         if (!other_param_type.IsSubtypeOf(param_type) &&
             !param_type.IsSubtypeOf(other_param_type)) {
           return false;
         }
         break;
       }
     }
     if (!found_param_name) {
@@ skipping 164 matching lines @@
       intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(&kLAngleBracket);
       const TypeArray& type_parameter_extends = TypeArray::Handle(
           function_class.type_parameter_extends());
       Type& parameter_extends = Type::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         String& type_parameter = String::ZoneHandle();
         type_parameter ^= type_parameters.At(i);
         pieces.Add(&type_parameter);
         parameter_extends = type_parameter_extends.TypeAt(i);
-        if (!parameter_extends.IsNull() && !parameter_extends.IsVarType()) {
+        if (!parameter_extends.IsNull() && !parameter_extends.IsDynamicType()) {
           pieces.Add(&kSpaceExtendsSpace);
           pieces.Add(&String::ZoneHandle(parameter_extends.Name()));
         }
         if (i < num_type_parameters - 1) {
           pieces.Add(&kCommaSpace);
         }
       }
       pieces.Add(&kRAngleBracket);
     }
   }
@@ skipping 1665 matching lines @@
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   *FieldAddrAtOffset(field_offset) = value.raw();
 }
 
 
 bool Instance::TestType(TypeTestKind test,
                         const Type& other,
                         const TypeArguments& other_instantiator) const {
   ASSERT(other.IsFinalized());
-  ASSERT(!other.IsVarType());
+  ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsVoidType());
   if (IsNull()) {
     if (test == Type::kIsSubtypeOf) {
       const Type& object_type =
           Type::Handle(Isolate::Current()->object_store()->object_type());
       if (other.IsInstantiated() && object_type.IsSubtypeOf(other)) {
         ASSERT(other_instantiator.IsNull());
         // null is an instance of the Object class.
         return true;
       }
@@ skipping 23 matching lines @@
   TypeArguments& other_type_arguments = TypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator, 0), however, we can save the
   // allocation of a new Type by inlining the code.
   if (other.IsTypeParameter()) {
     Type& instantiated_other = Type::Handle();
     if (!other_instantiator.IsNull()) {
       instantiated_other = other_instantiator.TypeAt(other.Index());
       ASSERT(instantiated_other.IsInstantiated());
     } else {
-      instantiated_other = Type::VarType();
+      instantiated_other = Type::DynamicType();
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
     if (!other_type_arguments.IsNull() &&
         !other_type_arguments.IsInstantiated()) {
       other_type_arguments =
           other_type_arguments.InstantiateFrom(other_instantiator, 0);
@@ skipping 2015 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart