Support for type dynamic in VM

runtime/vm/object.h

 // Copyright (c) 2012, 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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 369 matching lines @@
 
   // 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 RawArray* empty_array_;
   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* dynamic_class_;  // Class of the 'Dynamic' 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.
   // Class of the TypeArguments vm object.
   static RawClass* type_arguments_class_;
   static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
   static RawClass* patch_class_class_;  // Class of the PatchClass vm object.
   static RawClass* function_class_;  // Class of the Function vm object.
   static RawClass* closure_data_class_;  // Class of ClosureData vm obj.
   static RawClass* redirection_data_class_;  // Class of RedirectionData vm obj.
   static RawClass* field_class_;  // Class of the Field vm object.
@@ skipping 167 matching lines @@
   // Returns the list of classes having this class as direct superclass.
   RawGrowableObjectArray* direct_subclasses() const {
     return raw_ptr()->direct_subclasses_;
   }
   void AddDirectSubclass(const Class& subclass) const;
   // TODO(regis): Implement RemoveDirectSubclass for class unloading support.
 
   // Check if this class represents the class of null.
   bool IsNullClass() const { return id() == kNullCid; }
 
-  // Check if this class represents the 'Dynamic' class.
+  // Check if this class represents the 'dynamic' class.
   bool IsDynamicClass() const { return id() == kDynamicCid; }
 
   // Check if this class represents the 'void' class.
   bool IsVoidClass() const { return id() == kVoidCid; }
 
   // Check if this class represents the 'Object' class.
   bool IsObjectClass() const { return id() == kInstanceCid; }
 
   // Check if this class represents a signature class.
   bool IsSignatureClass() const {
@@ skipping 250 matching lines @@
   // 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.
   virtual RawAbstractTypeArguments* InstantiateFrom(
       const AbstractTypeArguments& instantiator_type_arguments) const;
 
   // Do not canonicalize InstantiatedTypeArguments or NULL objects
   virtual RawAbstractTypeArguments* Canonicalize() const { return this->raw(); }
 
-  // The name of this type argument vector, e.g. "<T, Dynamic, List<T>, Smi>".
+  // The name of this type argument vector, e.g. "<T, dynamic, List<T>, Smi>".
   virtual RawString* Name() const {
     return SubvectorName(0, Length(), kInternalName);
   }
 
-  // The name of this type argument vector, e.g. "<T, Dynamic, List<T>, int>".
+  // The name of this type argument vector, e.g. "<T, dynamic, List<T>, int>".
   // Names of internal classes are mapped to their public interfaces.
   virtual RawString* UserVisibleName() const {
     return SubvectorName(0, Length(), kUserVisibleName);
   }
 
   // Check if this type argument vector consists solely of DynamicType,
   // considering only a prefix of length 'len'.
   bool IsRaw(intptr_t len) const {
     return IsDynamicTypes(false, len);
   }
@@ skipping 45 matching lines @@
   bool IsDynamicTypes(bool raw_instantiated, intptr_t len) const;
 
   // Check the subtype or 'more specific' relationship, considering only a
   // prefix of length 'len'.
   bool TypeTest(TypeTestKind test_kind,
                 const AbstractTypeArguments& other,
                 intptr_t len,
                 Error* malformed_error) const;
 
   // Return the internal or public name of a subvector of this type argument
-  // vector, e.g. "<T, Dynamic, List<T>, int>".
+  // vector, e.g. "<T, dynamic, List<T>, int>".
   RawString* SubvectorName(intptr_t from_index,
                            intptr_t len,
                            NameVisibility name_visibility) const;
 
  protected:
   HEAP_OBJECT_IMPLEMENTATION(AbstractTypeArguments, Object);
   friend class AbstractType;
   friend class Class;
 };
 
@@ skipping 2151 matching lines @@
   // The name of this type, including the names of its type arguments, if any.
   // Names of internal classes are mapped to their public interfaces.
   virtual RawString* UserVisibleName() const {
     return BuildName(kUserVisibleName);
   }
 
   // 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 'Dynamic' type.
+  // Check if this type represents the 'dynamic' type.
   bool IsDynamicType() const {
     return HasResolvedTypeClass() && (type_class() == Object::dynamic_class());
   }
 
   // Check if this type represents the 'Null' type.
   bool IsNullType() const {
     return HasResolvedTypeClass() && (type_class() == Object::null_class());
   }
 
   // Check if this type represents the 'void' type.
@@ skipping 108 matching lines @@
       const AbstractTypeArguments& instantiator_type_arguments) const;
   virtual RawAbstractType* Canonicalize() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawType));
   }
 
   // The type of the literal 'null'.
   static RawType* NullType();
 
-  // The 'Dynamic' type.
+  // The 'dynamic' type.
   static RawType* DynamicType();
 
   // The 'void' type.
   static RawType* VoidType();
 
   // The 'Object' type.
   static RawType* ObjectType();
 
   // The 'bool' type.
   static RawType* BoolType();
@@ skipping 2540 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_