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

runtime/vm/class_finalizer.cc

 // 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.
 
 #include "vm/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 378 matching lines @@
     const intptr_t num_type_params = cls.NumTypeParameters();
     const intptr_t offset = cls.NumTypeArguments() - num_type_params;
     Type& type = Type::Handle();
     Type& type_extends = Type::Handle();
     const TypeArguments& extends_array =
         TypeArguments::Handle(cls.type_parameter_extends());
     ASSERT((extends_array.IsNull() && (num_type_params == 0)) ||
            (extends_array.Length() == num_type_params));
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_extends = extends_array.TypeAt(i);
-      if (!type_extends.IsVarType()) {
+      if (!type_extends.IsDynamicType()) {
         type = arguments.TypeAt(offset + i);
         if (type.IsInstantiated()) {
           if (!type_extends.IsInstantiated()) {
             type_extends = type_extends.InstantiateFrom(arguments, offset);
           }
           // TODO(regis): Where do we check the constraints when the type is
           // generic?
           if (!type.IsSubtypeOf(type_extends)) {
             const String& type_name = String::Handle(type.Name());
             const String& extends_name = String::Handle(type_extends.Name());
@@ skipping 79 matching lines @@
   }
   // The full type argument vector consists of the type arguments of the
   // super types of type_class, which may be initialized from the parsed
   // type arguments, followed by the parsed type arguments.
   if (num_type_arguments > 0) {
     const TypeArguments& full_arguments = TypeArguments::Handle(
         TypeArguments::NewTypeArray(num_type_arguments));
     // Copy the parsed type arguments at the correct offset in the full type
     // argument vector.
     const intptr_t offset = num_type_arguments - num_type_parameters;
-    Type& type = Type::Handle(Type::VarType());
+    Type& type = Type::Handle(Type::DynamicType());
     for (intptr_t i = 0; i < num_type_parameters; i++) {
       // If no type parameters were provided, a raw type is desired, so we
-      // create a vector of VarType.
+      // create a vector of DynamicType.
       if (!arguments.IsNull()) {
         type = arguments.TypeAt(i);
       }
       full_arguments.SetTypeAt(offset + i, type);
     }
     FinalizeTypeArguments(type_class, full_arguments);
     parameterized_type.set_arguments(full_arguments);
   }
 
   // If the type is a function type, finalize the result and parameter types.
@@ skipping 499 matching lines @@
   ASSERT(msg_buffer != NULL);
   va_list args;
   va_start(args, format);
   OS::VSNPrint(msg_buffer, kBufferLength, format, args);
   va_end(args);
   isolate->long_jump_base()->Jump(1, msg_buffer);
   UNREACHABLE();
 }
 
 }  // namespace dart