Remove definitions from Kernel canonical names.

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 116 matching lines @@
       ReadLibrary(kernel_library);
     }
 
     for (intptr_t i = 0; i < length; i++) {
       dart::Library& library =
           LookupLibrary(program_->libraries()[i]->canonical_name());
       if (!library.Loaded()) library.SetLoaded();
     }
 
     if (ClassFinalizer::ProcessPendingClasses(/*from_kernel=*/true)) {
-      Procedure* main = program_->main_method();
-      Library* kernel_main_library = Library::Cast(main->parent());
-      dart::Library& library =
-          LookupLibrary(kernel_main_library->canonical_name());
+      CanonicalName* main = program_->main_method();
+      dart::Library& library = LookupLibrary(main->Enclosing());

[Kevin Millikin (Google), 2017/03/29 11:50:30]

Maybe 'EnclosingName' because otherwise this reads like a verb?

 
       // Sanity check that we can find the main entrypoint.
       Object& main_obj = Object::Handle(
           Z, library.LookupObjectAllowPrivate(H.DartSymbol("main")));
       ASSERT(!main_obj.IsNull());
       return library;
     }
   }
 
   // Either class finalization failed or we caught a compile error.
@@ skipping 202 matching lines @@
     }
     klass.AddFields(fields_);
   }
 
   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);
+    const dart::String& name =
+        H.DartConstructorName(kernel_constructor->canonical_name());
     Function& function = dart::Function::ZoneHandle(
         Z, dart::Function::New(name, RawFunction::kConstructor,
                                false,  // is_static
                                kernel_constructor->IsConst(),
                                false,  // is_abstract
                                kernel_constructor->IsExternal(),
                                false,  // is_native
                                klass, kernel_constructor->position()));
     function.set_end_token_pos(kernel_constructor->end_position());
     functions_.Add(&function);
@@ skipping 33 matching lines @@
 
 void KernelReader::ReadProcedure(const dart::Library& library,
                                  const dart::Class& owner,
                                  Procedure* kernel_procedure,
                                  Class* kernel_klass) {
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &owner);
   ActiveMemberScope active_member_scope(&active_class_, kernel_procedure);
   ActiveFunctionScope active_function_scope(&active_class_,
                                             kernel_procedure->function());
 
-  const dart::String& name = H.DartProcedureName(kernel_procedure);
+  const dart::String& name =
+      H.DartProcedureName(kernel_procedure->canonical_name());
   bool is_method = kernel_klass != NULL && !kernel_procedure->IsStatic();
   bool is_abstract = kernel_procedure->IsAbstract();
   bool is_external = kernel_procedure->IsExternal();
   dart::String* native_name = NULL;
   if (is_external) {
     // Maybe it has a native implementation, which is not external as far as
     // the VM is concerned because it does have an implementation.  Check for
     // an ExternalName annotation and extract the string from it.
     for (int i = 0; i < kernel_procedure->annotations().length(); ++i) {
       Expression* annotation = kernel_procedure->annotations()[i];
       if (!annotation->IsConstructorInvocation()) continue;
       ConstructorInvocation* invocation =
           ConstructorInvocation::Cast(annotation);
-      Class* annotation_class = Class::Cast(invocation->target()->parent());
+      CanonicalName* annotation_class = invocation->target()->Enclosing();
+      ASSERT(annotation_class->IsClass());
       String* class_name = annotation_class->name();
       // Just compare by name, do not generate the annotation class.
       int length = sizeof("ExternalName") - 1;
       if (class_name->size() != length) continue;
       if (memcmp(class_name->buffer(), "ExternalName", length) != 0) continue;
+      ASSERT(annotation_class->parent()->IsLibrary());
       String* library_name = annotation_class->parent()->name();
-      length = sizeof("dart._internal") - 1;
+      length = sizeof("dart:_internal") - 1;
       if (library_name->size() != length) continue;
-      if (memcmp(library_name->buffer(), "dart._internal", length) != 0) {
+      if (memcmp(library_name->buffer(), "dart:_internal", length) != 0) {
         continue;
       }
 
       is_external = false;
       ASSERT(invocation->arguments()->positional().length() == 1 &&
              invocation->arguments()->named().length() == 0);
       StringLiteral* literal =
           StringLiteral::Cast(invocation->arguments()->positional()[0]);
       native_name = &H.DartSymbol(literal->value());
       break;
@@ skipping 35 matching lines @@
   if (native_name != NULL) {
     function.set_native_name(*native_name);
   }
 
   SetupFunctionParameters(H, T, owner, function, kernel_procedure->function(),
                           is_method,
                           false);  // is_closure
 
   if (kernel_klass == NULL) {
     library.AddObject(function, name);
-    ASSERT(!Object::Handle(Z, library.LookupObjectAllowPrivate(
-                                  H.DartProcedureName(kernel_procedure)))
+    ASSERT(!Object::Handle(
+                Z, library.LookupObjectAllowPrivate(
+                       H.DartProcedureName(kernel_procedure->canonical_name())))
                 .IsNull());
   }
   if (FLAG_enable_mirrors) {
     library.AddFunctionMetadata(function, TokenPosition::kNoSource,
                                 kernel_procedure);
   }
 }
 
 const Object& KernelReader::ClassForScriptAt(const dart::Class& klass,
                                              intptr_t source_uri_index) {
@@ skipping 114 matching lines @@
       // Note: optimizer relies on DoubleInitialized bit in its field-unboxing
       // heuristics. See JitOptimizer::VisitStoreInstanceField for more details.
       field.RecordStore(converter.SimpleValue());
       if (!converter.SimpleValue().IsNull() &&
           converter.SimpleValue().IsDouble()) {
         field.set_is_double_initialized(true);
       }
     }
   }
 
-  const dart::String& getter_name = H.DartGetterName(kernel_field->name());
+  const dart::String& getter_name =
+      H.DartGetterName(kernel_field->canonical_name());
   const Object& script_class =
       ClassForScriptAt(klass, kernel_field->source_uri_index());
   Function& getter = Function::ZoneHandle(
       Z,
       Function::New(
           getter_name,
           kernel_field->IsStatic() ? RawFunction::kImplicitStaticFinalGetter
                                    : RawFunction::kImplicitGetter,
           kernel_field->IsStatic(),
           // The functions created by the parser have is_const for static fields
           // that are const (not just final) and they have is_const for
           // non-static
           // fields that are final.
           kernel_field->IsStatic() ? kernel_field->IsConst()
                                    : kernel_field->IsFinal(),
           false,  // is_abstract
           false,  // is_external
           false,  // is_native
           script_class, kernel_field->position()));
   functions_.Add(&getter);
   getter.set_end_token_pos(kernel_field->end_position());
   getter.set_kernel_function(kernel_field);
   getter.set_result_type(AbstractType::Handle(Z, field.type()));
   getter.set_is_debuggable(false);
   SetupFieldAccessorFunction(klass, getter);
 
   if (!kernel_field->IsStatic() && !kernel_field->IsFinal()) {
     // Only static fields can be const.
     ASSERT(!kernel_field->IsConst());
-    const dart::String& setter_name = H.DartSetterName(kernel_field->name());
+    const dart::String& setter_name =
+        H.DartSetterName(kernel_field->canonical_name());
     Function& setter = Function::ZoneHandle(
         Z, Function::New(setter_name, RawFunction::kImplicitSetter,
                          false,  // is_static
                          false,  // is_const
                          false,  // is_abstract
                          false,  // is_external
                          false,  // is_native
                          script_class, kernel_field->position()));
     functions_.Add(&setter);
     setter.set_end_token_pos(kernel_field->end_position());
@@ skipping 186 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)