VM: Restore old implementation of ClassID.cid* fields

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/longjump.h"
@@ skipping 270 matching lines @@
 
 
 dart::Class& KernelReader::ReadClass(const dart::Library& library,
                                      const dart::Class& toplevel_class,
                                      Class* kernel_klass) {
   // This will trigger a call to [ReadPreliminaryClass] if not already done.
   dart::Class& klass = LookupClass(kernel_klass);
 
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
 
-  for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
-    Field* kernel_field = kernel_klass->fields()[i];
-    ActiveMemberScope active_member_scope(&active_class_, kernel_field);
+  if (library.raw() == dart::Library::InternalLibrary() &&
+      klass.Name() == Symbols::ClassID().raw()) {
+    // If this is a dart:internal.ClassID class ignore field declarations
+    // contained in the Kernel file and instead inject our own const
+    // fields.
+    klass.InjectCIDFields();
+  } else {
+    for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
+      Field* kernel_field = kernel_klass->fields()[i];
+      ActiveMemberScope active_member_scope(&active_class_, kernel_field);
 
-    const dart::String& name = H.DartFieldName(kernel_field->name());
-    const AbstractType& type =
-        T.TranslateTypeWithoutFinalization(kernel_field->type());
-    const Object& script_class =
-        ClassForScriptAt(klass, kernel_field->source_uri_index());
-    dart::Field& field = dart::Field::Handle(
-        Z, dart::Field::New(name, kernel_field->IsStatic(),
-                            // In the VM all const fields are implicitly final
-                            // whereas in Kernel they are not final because they
-                            // are not explicitly declared that way.
-                            kernel_field->IsFinal() || kernel_field->IsConst(),
-                            kernel_field->IsConst(),
-                            false,  // is_reflectable
-                            script_class, type, kernel_field->position()));
-    field.set_kernel_field(kernel_field);
-    field.set_has_initializer(kernel_field->initializer() != NULL);
-    GenerateFieldAccessors(klass, field, kernel_field);
-    klass.AddField(field);
+      const dart::String& name = H.DartFieldName(kernel_field->name());
+      const AbstractType& type =
+          T.TranslateTypeWithoutFinalization(kernel_field->type());
+      const Object& script_class =
+          ClassForScriptAt(klass, kernel_field->source_uri_index());
+      dart::Field& field = dart::Field::Handle(
+          Z,
+          dart::Field::New(name, kernel_field->IsStatic(),
+                           // In the VM all const fields are implicitly final
+                           // whereas in Kernel they are not final because they
+                           // are not explicitly declared that way.
+                           kernel_field->IsFinal() || kernel_field->IsConst(),
+                           kernel_field->IsConst(),
+                           false,  // is_reflectable
+                           script_class, type, kernel_field->position()));
+      field.set_kernel_field(kernel_field);
+      field.set_has_initializer(kernel_field->initializer() != NULL);
+      GenerateFieldAccessors(klass, field, kernel_field);
+      klass.AddField(field);
+    }
   }
 
   for (intptr_t i = 0; i < kernel_klass->constructors().length(); i++) {
     Constructor* kernel_constructor = kernel_klass->constructors()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_constructor);
     ActiveFunctionScope active_function_scope(&active_class_,
                                               kernel_constructor->function());
 
     const dart::String& name = H.DartConstructorName(kernel_constructor);
     Function& function = dart::Function::ZoneHandle(
@@ skipping 466 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)