Support for type dynamic in VM

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 864 matching lines @@
   // allocated, because the classes reside in the VM isolate.
   // The corresponding types are stored in the object store.
   cls = null_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_null_type(type);
 
   cls = void_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_void_type(type);
 
-  // The class 'Dynamic' is registered in the class dictionary because its name
+  // The class 'dynamic' is registered in the class dictionary because its name
   // is a built-in identifier, rather than a reserved keyword. Its name is not
   // heap allocated, because the class resides in the VM isolate.
   // The corresponding type, the "unknown type", is stored in the object store.
   cls = dynamic_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_dynamic_type(type);
 
   // Allocate pre-initialized values.
   Bool& bool_value = Bool::Handle();
   bool_value = Bool::New(true);
@@ skipping 1107 matching lines @@
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
 bool Class::TypeTest(
     TypeTestKind test_kind,
     const AbstractTypeArguments& type_arguments,
     const Class& other,
     const AbstractTypeArguments& other_type_arguments,
     Error* malformed_error) const {
   ASSERT(!IsVoidClass());
   // Check for DynamicType.
-  // Each occurrence of DynamicType in type T is interpreted as the Dynamic
+  // Each occurrence of DynamicType in type T is interpreted as the dynamic
   // type, a supertype of all types.
   if (other.IsDynamicClass()) {
     return true;
   }
   // In the case of a subtype test, each occurrence of DynamicType in type S is
   // interpreted as the bottom type, a subtype of all types.
   // However, DynamicType is not more specific than any type.
   if (IsDynamicClass()) {
     return test_kind == kIsSubtypeOf;
   }
@@ skipping 557 matching lines @@
 bool AbstractTypeArguments::IsDynamicTypes(bool raw_instantiated,
                                            intptr_t len) const {
   ASSERT(Length() >= len);
   AbstractType& type = AbstractType::Handle();
   Class& type_class = Class::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     if (!type.HasResolvedTypeClass()) {
       if (raw_instantiated && type.IsTypeParameter()) {
-        // An uninstantiated type parameter is equivalent to Dynamic.
+        // An uninstantiated type parameter is equivalent to dynamic.
         continue;
       }
       ASSERT((!raw_instantiated && type.IsTypeParameter()) ||
              type.IsMalformed());
       return false;
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
@@ skipping 5436 matching lines @@
       // are not the Object::null() instance.
       ASSERT((raw() == Object::transition_sentinel()) ||
              (raw() == Object::sentinel()));
       ASSERT(!FLAG_eliminate_type_checks);
       return true;  // We are doing an instance of test as part of a type check.
     }
     // The null instance can be returned from a void function.
     if (other.IsVoidType()) {
       return true;
     }
-    // Otherwise, null is only an instance of Object and of Dynamic.
+    // Otherwise, null is only an instance of Object and of dynamic.
     // It is not necessary to fully instantiate the other type for this test.
     Class& other_class = Class::Handle();
     if (other.IsTypeParameter()) {
       if (other_instantiator.IsNull()) {
-        return true;  // Other type is uninstantiated, i.e. Dynamic.
+        return true;  // Other type is uninstantiated, i.e. dynamic.
       }
       const TypeParameter& other_type_param = TypeParameter::Cast(other);
       const AbstractType& instantiated_other = AbstractType::Handle(
           other_instantiator.TypeAt(other_type_param.index()));
       ASSERT(instantiated_other.IsInstantiated());
       other_class = instantiated_other.type_class();
     } else {
       other_class = other.type_class();
     }
     return other_class.IsObjectClass() || other_class.IsDynamicClass();
@@ skipping 20 matching lines @@
            (cls.IsSignatureClass() &&
             (type_arguments.Length() > num_type_arguments)));
   }
   Class& other_class = Class::Handle();
   AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator), however, we can save the
   // allocation of a new AbstractType by inlining the code.
   if (other.IsTypeParameter()) {
     if (other_instantiator.IsNull()) {
-      // An uninstantiated type parameter is equivalent to Dynamic.
+      // An uninstantiated type parameter is equivalent to dynamic.
       return true;
     }
     const TypeParameter& other_type_param = TypeParameter::Cast(other);
     AbstractType& instantiated_other = AbstractType::Handle(
         other_instantiator.TypeAt(other_type_param.index()));
     if (instantiated_other.IsDynamicType() ||
         instantiated_other.IsTypeParameter()) {
       return true;
     }
     other_class = instantiated_other.type_class();
@@ skipping 209 matching lines @@
     if (name_visibility == kInternalName) {
       class_name = cls.Name();
     } else {
       ASSERT(name_visibility == kUserVisibleName);
       // Map internal types to their corresponding public interfaces.
       class_name = cls.UserVisibleName();
     }
     if (num_type_params > num_args) {
       first_type_param_index = 0;
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
-        // Most probably a malformed type. Do not fill up with "Dynamic",
+        // Most probably a malformed type. Do not fill up with "dynamic",
         // but use actual vector.
         num_type_params = num_args;
       } else {
         ASSERT(num_args == 0);  // Type is raw.
-        // No need to fill up with "Dynamic".
+        // No need to fill up with "dynamic".
         num_type_params = 0;
       }
     } else {
       first_type_param_index = num_args - num_type_params;
     }
     if (cls.IsSignatureClass()) {
       // We may be reporting an error about a malformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
         return class_name.raw();
@@ skipping 3861 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart