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

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 100 matching lines @@
 
 class Object {
  public:
   // Index for Singleton internal VM classes,
   // this index is used in snapshots to refer to these classes directly.
   enum {
     kNullObject = 0,
     kSentinelObject,
     kClassClass,
     kNullClass,
-    kVarClass,
+    kDynamicClass,
     kVoidClass,
     kUnresolvedClassClass,
     kParameterizedTypeClass,
     kTypeParameterClass,
     kInstantiatedTypeClass,
     kTypeArgumentsClass,
     kTypeArrayClass,
     kInstantiatedTypeArgumentsClass,
     kFunctionClass,
     kFieldClass,
@@ skipping 71 matching lines @@
   // The sentinel is a value that cannot be produced by Dart code.
   // It can be used to mark special values, for example to distinguish
   // "uninitialized" fields.
   static RawInstance* sentinel() { return sentinel_; }
   // Value marking that we are transitioning from sentinel, e.g., computing
   // a field value. Used to detect circular initialization.
   static RawInstance* transition_sentinel() { return transition_sentinel_; }
 
   static RawClass* class_class() { return class_class_; }
   static RawClass* null_class() { return null_class_; }
-  static RawClass* var_class() { return var_class_; }
+  static RawClass* dynamic_class() { return dynamic_class_; }
   static RawClass* void_class() { return void_class_; }
   static RawClass* unresolved_class_class() { return unresolved_class_class_; }
   static RawClass* parameterized_type_class() {
       return parameterized_type_class_;
   }
   static RawClass* type_parameter_class() { return type_parameter_class_; }
   static RawClass* instantiated_type_class() {
       return instantiated_type_class_;
   }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
@@ skipping 80 matching lines @@
   static cpp_vtable handle_vtable_;
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
   static RawInstance* sentinel_;
   static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
-  static RawClass* var_class_;  // Class of the 'var' type.
+  static RawClass* dynamic_class_;  // Class of the 'Dynamic' type.
   static RawClass* void_class_;  // Class of the 'void' type.
   static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
   static RawClass* parameterized_type_class_;  // Class of ParameterizedType.
   static RawClass* type_parameter_class_;  // Class of TypeParameter vm object.
   static RawClass* instantiated_type_class_;  // Class of InstantiatedType.
   static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
   static RawClass* type_array_class_;  // Class of the TypeArray vm object.
   static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
   static RawClass* function_class_;  // Class of the Function vm object.
   static RawClass* field_class_;  // Class of the Field vm object.
@@ skipping 77 matching lines @@
   RawType* SignatureType() const;
 
   RawLibrary* library() const { return raw_ptr()->library_; }
   void set_library(const Library& value) const;
 
   // The type parameters are specified as an array of Strings.
   RawArray* type_parameters() const { return raw_ptr()->type_parameters_; }
   void set_type_parameters(const Array& value) const;
   intptr_t NumTypeParameters() const;
 
-  // Type parameters may optionally extend a Type (VarType if no extends).
+  // Type parameters may optionally extend a Type (DynamicType if no extends).
   RawTypeArray* type_parameter_extends() const {
     return raw_ptr()->type_parameter_extends_;
   }
   void set_type_parameter_extends(const TypeArray& value) const;
 
   // Return a TypeParameter if the type_name is a type parameter of this class.
   // Return null otherwise.
   RawTypeParameter* LookupTypeParameter(const String& type_name) const;
 
   // If this class is parameterized, each instance has a type_arguments field.
@@ skipping 37 matching lines @@
   RawArray* functions_cache() const { return raw_ptr()->functions_cache_; }
   void set_functions_cache(const Array& value) const;
 
   static intptr_t functions_cache_offset() {
     return OFFSET_OF(RawClass, functions_cache_);
   }
 
   // Check if this class represents the class of null.
   bool IsNullClass() const { return raw() == Object::null_class(); }
 
-  // Check if this class represents the 'var' class.
-  bool IsVarClass() const { return raw() == Object::var_class(); }
+  // Check if this class represents the 'Dynamic' class.
+  bool IsDynamicClass() const { return raw() == Object::dynamic_class(); }
 
   // Check if this class represents the 'void' class.
   bool IsVoidClass() const { return raw() == Object::void_class(); }
 
   // Check if this class represents the 'Object' class.
   bool IsObjectClass() const;
 
   // Check if this class represents a signature class.
   bool IsSignatureClass() const {
     return signature_function() != Object::null();
@@ skipping 210 matching lines @@
 
   // The name of this type's class, i.e. without the type argument names of this
   // type.
   RawString* ClassName() const;
 
   // Check if this type represents the 'null' type.
   bool IsNullType() const {
     return HasResolvedTypeClass() && (type_class() == Object::null_class());
   }
 
-  // Check if this type represents the 'var' type.
-  bool IsVarType() const {
-    return HasResolvedTypeClass() && (type_class() == Object::var_class());
+  // Check if this type represents the 'Dynamic' type.
+  bool IsDynamicType() const {
+    return HasResolvedTypeClass() && (type_class() == Object::dynamic_class());
   }
 
   // Check if this type represents the 'void' type.
   bool IsVoidType() const {
     return HasResolvedTypeClass() && (type_class() == Object::void_class());
   }
 
   // Check if this type represents the 'bool' interface.
   bool IsBoolInterface() const;
 
@@ skipping 30 matching lines @@
   }
 
   // Check the assignability relationship.
   bool IsAssignableTo(const Type& dst) const {
     return Test(kIsAssignableTo, dst);
   }
 
   // The type of the literal 'null'.
   static RawType* NullType();
 
-  // The 'var' type.
-  static RawType* VarType();
+  // The 'Dynamic' type.
+  static RawType* DynamicType();
 
   // The 'void' type.
   static RawType* VoidType();
 
   // The 'Object' type.
   static RawType* ObjectType();
 
   // The 'bool' interface type.
   static RawType* BoolInterface();
 
   // The 'int' interface type.
   static RawType* IntInterface();
 
   // The 'double' interface type.
   static RawType* DoubleInterface();
 
   // The 'num' interface type.
   static RawType* NumberInterface();
 
   // The 'String' interface type.
   static RawType* StringInterface();
 
   // The 'Function' interface type.
   static RawType* FunctionInterface();
 
   // The least specific valid raw type of the given class.
-  // For example, type A<VarType> would be returned for class A<T>, and type
-  // B<VarType, A<VarType>> would be returned for B<U, V extends A>.
+  // For example, type A<DynamicType> would be returned for class A<T>, and type
+  // B<DynamicType, A<DynamicType>> would be returned for B<U, V extends A>.
   static RawType* NewRawType(const Class& type_class);
 
   // The finalized type of the given non-parameterized class.
   static RawType* NewNonParameterizedType(const Class& type_class);
 
   static RawType* NewParameterizedType(const Object& type_class,
                                        const TypeArguments& arguments);
 
   static RawType* NewTypeParameter(intptr_t index, const String& name);
 
@@ skipping 142 matching lines @@
   virtual bool IsUninstantiatedIdentity() const;
 
   // Return 'this' if this type argument vector is instantiated, i.e. if it does
   // not refer to type parameters. Otherwise, return a new type argument vector
   // where each reference to a type parameter is replaced with the corresponding
   // type of the instantiator type argument vector starting at the given offset.
   virtual RawTypeArguments* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
-  // Check if this type argument vector consists solely of VarType, considering
-  // only a prefix of length 'len'.
-  bool IsVarTypes(intptr_t len) const;
+  // Check if this type argument vector consists solely of DynamicType,
+  // considering only a prefix of length 'len'.
+  bool IsDynamicTypes(intptr_t len) const;
 
   // Check the "more specific than" relationship, considering only a prefix of
   // length 'len'.
   bool IsMoreSpecificThan(const TypeArguments& other, intptr_t len) const;
 
   static RawTypeArguments* NewTypeArray(intptr_t len);
 
   static RawTypeArguments* NewInstantiatedTypeArguments(
       const TypeArguments& uninstantiated_type_arguments,
       const TypeArguments& instantiator_type_arguments);
@@ skipping 2008 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_