Support for type dynamic in VM

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 614 matching lines @@
   if (!cls.is_finalized()) {
     FinalizeTypeParameters(cls);
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle();
     if (super_type.IsBeingFinalized()) {
       // This type references itself via its type arguments. This is legal, but
       // we must avoid endless recursion. We therefore map the innermost
-      // super type to Dynamic.
+      // super type to dynamic.
       // Note that a direct self-reference via the super class chain is illegal
       // and reported as an error earlier.
       // Such legal self-references occur with F-bounded quantification.
       // Example 1: class Derived extends Base<Derived>.
       // The type 'Derived' forms a cycle by pointing to itself via its
       // flattened type argument vector: Derived[Base[Derived[Base[...]]]]
-      // We break the cycle as follows: Derived[Base[Derived[Dynamic]]]
+      // We break the cycle as follows: Derived[Base[Derived[dynamic]]]
       // Example 2: class Derived extends Base<Middle<Derived>> results in
-      // Derived[Base[Middle[Derived[Dynamic]]]]
+      // Derived[Base[Middle[Derived[dynamic]]]]
       // Example 3: class Derived<T> extends Base<Derived<T>> results in
-      // Derived[Base[Derived[Dynamic]], T].
-      ASSERT(super_type_args.IsNull());  // Same as a vector of Dynamic.
+      // Derived[Base[Derived[dynamic]], T].
+      ASSERT(super_type_args.IsNull());  // Same as a vector of dynamic.
     } else {
       super_type ^= FinalizeType(cls, super_type, finalization);
       cls.set_super_type(super_type);
       super_type_args = super_type.arguments();
     }
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t offset = super_class.NumTypeArguments();
     const intptr_t super_offset = offset - num_super_type_params;
     ASSERT(offset == (cls.NumTypeArguments() - cls.NumTypeParameters()));
     AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
@@ skipping 89 matching lines @@
         // Malformed type arguments to a constructor of a generic type are
         // reported as a compile-time error.
         if (finalization >= kCanonicalizeForCreation) {
           const Script& script = Script::Handle(cls.script());
           const String& type_name =
               String::Handle(parameterized_type.UserVisibleName());
           ReportError(script, parameterized_type.token_pos(),
                       "type '%s' has malformed type argument",
                       type_name.ToCString());
         }
-        // In production mode, malformed type arguments are mapped to Dynamic.
+        // In production mode, malformed type arguments are mapped to dynamic.
         // In checked mode, a type with malformed type arguments is malformed.
         if (FLAG_enable_type_checks || FLAG_error_on_malformed_type) {
           const Error& error = Error::Handle(type_argument.malformed_error());
           const String& type_name =
               String::Handle(parameterized_type.UserVisibleName());
           FinalizeMalformedType(error, cls, parameterized_type, finalization,
                                 "type '%s' has malformed type argument",
                                 type_name.ToCString());
           return parameterized_type.raw();
         } else {
@@ skipping 150 matching lines @@
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   // In case of a factory, the parser sets the factory result type to a type
   // with an unresolved class whose name matches the factory name.
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
   ResolveType(cls, type, kCanonicalize);
   type = FinalizeType(cls, type, kCanonicalize);
-  // In production mode, a malformed result type is mapped to Dynamic.
+  // In production mode, a malformed result type is mapped to dynamic.
   if (!FLAG_enable_type_checks && type.IsMalformed()) {
     type = Type::DynamicType();
   }
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type, kCanonicalize);
     type = FinalizeType(cls, type, kCanonicalize);
-    // In production mode, a malformed parameter type is mapped to Dynamic.
+    // In production mode, a malformed parameter type is mapped to dynamic.
     if (!FLAG_enable_type_checks && type.IsMalformed()) {
       type = Type::DynamicType();
     }
     function.SetParameterTypeAt(i, type);
   }
 }
 
 
 static RawClass* FindSuperOwnerOfInstanceMember(const Class& cls,
                                                 const String& name) {
@@ skipping 427 matching lines @@
                   String::Handle(interface.Name()).ToCString());
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "'%s' is used where an interface or class name is expected",
                   String::Handle(interface_class.Name()).ToCString());
     }
     // Verify that unless cls belongs to core lib, it cannot extend or implement
-    // any of bool, num, int, double, String, Function, Dynamic.
+    // any of bool, num, int, double, String, Function, dynamic.
     // The exception is signature classes, which are compiler generated and
     // represent a function type, therefore implementing the Function interface.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolType() ||
           interface.IsNumberType() ||
           interface.IsIntType() ||
           interface.IsDoubleType() ||
           interface.IsStringInterface() ||
           (interface.IsFunctionType() && !cls.IsSignatureClass()) ||
           interface.IsDynamicType()) {
@@ skipping 187 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart