Support for type dynamic in VM

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 359 matching lines @@
 
   // If the compile type of the value is void, we are type checking the result
   // of a void function, which was checked to be null at the return statement
   // inside the function.
   if (compile_type.IsVoidType()) {
     ASSERT(FLAG_enable_type_checks);
     *is_instance = true;
     return true;
   }
 
-  // The Null type is only a subtype of Object and of Dynamic.
+  // The Null type is only a subtype of Object and of dynamic.
   // Functions that do not explicitly return a value, implicitly return null,
   // except generative constructors, which return the object being constructed.
   // It is therefore acceptable for void functions to return null.
   if (compile_type.IsNullType()) {
     *is_instance =
         type.IsObjectType() || type.IsDynamicType() || type.IsVoidType();
     return true;
   }
 
   // Until we support a set of compile types, we can only give answers for
@@ skipping 567 matching lines @@
 
 
 RawAbstractType* StoreContextInstr::CompileType() const {
   return AbstractType::null();
 }
 
 
 RawAbstractType* ClosureCallInstr::CompileType() const {
   // Because of function subtyping rules, the declared return type of a closure
   // call cannot be relied upon for compile type analysis. For example, a
-  // function returning Dynamic can be assigned to a closure variable declared
+  // function returning dynamic can be assigned to a closure variable declared
   // to return int and may actually return a double at run-time.
   return Type::DynamicType();
 }
 
 
 RawAbstractType* InstanceCallInstr::CompileType() const {
-  // TODO(regis): Return a more specific type than Dynamic for recognized
+  // TODO(regis): Return a more specific type than dynamic for recognized
   // combinations of receiver type and method name.
   return Type::DynamicType();
 }
 
 
 RawAbstractType* PolymorphicInstanceCallInstr::CompileType() const {
   return Type::DynamicType();
 }
 
 
@@ skipping 132 matching lines @@
 
 
 RawAbstractType* AllocateObjectWithBoundsCheckInstr::CompileType() const {
   // TODO(regis): Be more specific.
   return Type::DynamicType();
 }
 
 
 RawAbstractType* LoadFieldInstr::CompileType() const {
   // Type may be null if the field is a VM field, e.g. context parent.
-  // Keep it as null for debug purposes and do not return Dynamic in production
+  // Keep it as null for debug purposes and do not return dynamic in production
   // mode, since misuse of the type would remain undetected.
   if (type().IsNull()) {
     return AbstractType::null();
   }
   if (FLAG_enable_type_checks) {
     return type().raw();
   }
   return Type::DynamicType();
 }
 
@@ skipping 947 matching lines @@
     new_max = new_max.Clamp();
   }
 
   return Range::Update(&range_, new_min, new_max);
 }
 
 
 #undef __
 
 }  // namespace dart