Remove definitions from Kernel canonical names.

runtime/vm/kernel_to_il.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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 259 matching lines @@
 
   ParsedFunction* parsed_function = parsed_function_;
   const dart::Function& function = parsed_function->function();
 
   // Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
   // e.g. for type translation.
   const dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
   Function& outermost_function = Function::Handle(Z);
   TreeNode* outermost_node = NULL;
-  Class* kernel_klass = NULL;
+  Class* kernel_class = NULL;
   DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
-                            &kernel_klass);
-  // Use [klass]/[kernel_klass] as active class.  Type parameters will get
-  // resolved via [kernel_klass] unless we are nested inside a static factory
+                            &kernel_class);
+  // Use [klass]/[kernel_class] as active class.  Type parameters will get
+  // resolved via [kernel_class] unless we are nested inside a static factory
   // in which case we will use [member].
-  ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
+  ActiveClassScope active_class_scope(&active_class_, kernel_class, &klass);
   Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
                        ? Member::Cast(outermost_node)
                        : NULL;
   ActiveMemberScope active_member(&active_class_, member);
 
 
   LocalScope* enclosing_scope = NULL;
   if (function.IsLocalFunction()) {
     enclosing_scope = LocalScope::RestoreOuterScope(
         ContextScope::Handle(Z, function.context_scope()));
@@ skipping 766 matching lines @@
 }
 
 
 dart::String& TranslationHelper::DartSymbol(String* content) const {
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromUTF8(thread_, content->buffer(), content->size()));
 }
 
 
 const dart::String& TranslationHelper::DartClassName(
-    CanonicalName* kernel_klass) {
-  dart::String& name = DartString(kernel_klass->name());
-  return ManglePrivateName(kernel_klass->parent(), &name);
+    CanonicalName* kernel_class) {
+  ASSERT(kernel_class->IsClass());
+  dart::String& name = DartString(kernel_class->name());
+  return ManglePrivateName(kernel_class->parent(), &name);
 }
 
 
-const dart::String& TranslationHelper::DartConstructorName(Constructor* node) {
-  Class* klass = Class::Cast(node->parent());
-  return DartFactoryName(klass, node->name());
+const dart::String& TranslationHelper::DartConstructorName(
+    CanonicalName* constructor) {
+  ASSERT(constructor->IsConstructor());
+  return DartFactoryName(constructor);
 }
 
 
-const dart::String& TranslationHelper::DartProcedureName(Procedure* procedure) {
-  if (procedure->kind() == Procedure::kSetter) {
-    return DartSetterName(procedure->name());
-  } else if (procedure->kind() == Procedure::kGetter) {
-    return DartGetterName(procedure->name());
-  } else if (procedure->kind() == Procedure::kFactory) {
-    return DartFactoryName(Class::Cast(procedure->parent()), procedure->name());
+const dart::String& TranslationHelper::DartProcedureName(
+    CanonicalName* procedure) {
+  ASSERT(procedure->IsProcedure());
+  if (procedure->IsSetter()) {
+    return DartSetterName(procedure);
+  } else if (procedure->IsGetter()) {
+    return DartGetterName(procedure);
+  } else if (procedure->IsFactory()) {
+    return DartFactoryName(procedure);
   } else {
-    return DartMethodName(procedure->name());
+    return DartMethodName(procedure);
   }
 }
 
 
-const dart::String& TranslationHelper::DartSetterName(Name* kernel_name) {
-  // The names flowing into [content] are coming from the Kernel file:
+const dart::String& TranslationHelper::DartSetterName(CanonicalName* setter) {
+  return DartSetterName(setter->parent(), setter->name());
+}
+
+
+const dart::String& TranslationHelper::DartSetterName(Name* setter_name) {
+  return DartSetterName(setter_name->library(), setter_name->string());
+}
+
+
+const dart::String& TranslationHelper::DartSetterName(CanonicalName* parent,
+                                                      String* setter) {
+  // The names flowing into [setter] are coming from the Kernel file:
   //   * user-defined setters: `fieldname=`
   //   * property-set expressions:  `fieldname`
   //
   // The VM uses `get:fieldname` and `set:fieldname`.
   //
   // => In order to be consistent, we remove the `=` always and adopt the VM
   //    conventions.
-  String* content = kernel_name->string();
-  ASSERT(content->size() > 0);
+  ASSERT(setter->size() > 0);
   intptr_t skip = 0;
-  if (content->buffer()[content->size() - 1] == '=') {
+  if (setter->buffer()[setter->size() - 1] == '=') {
     skip = 1;
   }
   dart::String& name = dart::String::ZoneHandle(
-      Z, dart::String::FromUTF8(content->buffer(), content->size() - skip,
+      Z, dart::String::FromUTF8(setter->buffer(), setter->size() - skip,
                                 allocation_space_));
-  ManglePrivateName(kernel_name->library_reference(), &name, false);
+  ManglePrivateName(parent, &name, false);
   name = dart::Field::SetterSymbol(name);
   return name;
 }
 
 
-const dart::String& TranslationHelper::DartGetterName(Name* kernel_name) {
-  dart::String& name = DartString(kernel_name->string());
-  ManglePrivateName(kernel_name->library_reference(), &name, false);
+const dart::String& TranslationHelper::DartGetterName(CanonicalName* getter) {
+  return DartGetterName(getter->parent(), getter->name());
+}
+
+
+const dart::String& TranslationHelper::DartGetterName(Name* getter_name) {
+  return DartGetterName(getter_name->library(), getter_name->string());
+}
+
+
+const dart::String& TranslationHelper::DartGetterName(CanonicalName* parent,
+                                                      String* getter) {
+  dart::String& name = DartString(getter);
+  ManglePrivateName(parent, &name, false);
   name = dart::Field::GetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartFieldName(Name* kernel_name) {
   dart::String& name = DartString(kernel_name->string());
-  return ManglePrivateName(kernel_name->library_reference(), &name);
+  return ManglePrivateName(kernel_name->library(), &name);
 }
 
 
 const dart::String& TranslationHelper::DartInitializerName(Name* kernel_name) {
   // The [DartFieldName] will take care of mangling the name.
   dart::String& name =
       dart::String::Handle(Z, DartFieldName(kernel_name).raw());
   name = Symbols::FromConcat(thread_, Symbols::InitPrefix(), name);
   return name;
 }
 
 
-const dart::String& TranslationHelper::DartMethodName(Name* kernel_name) {
-  dart::String& name = DartString(kernel_name->string());
-  return ManglePrivateName(kernel_name->library_reference(), &name);
+const dart::String& TranslationHelper::DartMethodName(CanonicalName* method) {
+  return DartMethodName(method->parent(), method->name());
 }
 
 
-const dart::String& TranslationHelper::DartFactoryName(Class* klass,
-                                                       Name* method_name) {
+const dart::String& TranslationHelper::DartMethodName(Name* method_name) {
+  return DartMethodName(method_name->library(), method_name->string());
+}
+
+
+const dart::String& TranslationHelper::DartMethodName(CanonicalName* parent,
+                                                      String* method) {
+  dart::String& name = DartString(method);
+  return ManglePrivateName(parent, &name);
+}
+
+
+const dart::String& TranslationHelper::DartFactoryName(CanonicalName* factory) {
+  ASSERT(factory->IsConstructor() || factory->IsFactory());
+  GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
+  pieces.Add(DartClassName(factory->EnclosingName()));
+  pieces.Add(Symbols::Dot());
   // [DartMethodName] will mangle the name.
-  GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
-  pieces.Add(DartClassName(klass->canonical_name()));
-  pieces.Add(Symbols::Dot());
-  pieces.Add(DartMethodName(method_name));
+  pieces.Add(DartMethodName(factory));
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromConcatAll(thread_, pieces));
 }
 
 
 dart::RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
     CanonicalName* kernel_library) {
+  // We only use the name and don't rely on having any particular parent.  This
+  // ASSERT is just a sanity check.
+  ASSERT(kernel_library->IsLibrary() ||
+         kernel_library->parent()->IsAdministrative());
   const dart::String& library_name = DartSymbol(kernel_library->name());
   ASSERT(!library_name.IsNull());
   dart::RawLibrary* library =
       dart::Library::LookupLibrary(thread_, library_name);
   ASSERT(library != Object::null());
   return library;
 }
 
 
 dart::RawClass* TranslationHelper::LookupClassByKernelClass(
-    CanonicalName* kernel_klass) {
+    CanonicalName* kernel_class) {
+  ASSERT(kernel_class->IsClass());
   dart::RawClass* klass = NULL;
-
-  const dart::String& class_name = DartClassName(kernel_klass);
-  CanonicalName* kernel_library = kernel_klass->parent();
+  const dart::String& class_name = DartClassName(kernel_class);
+  CanonicalName* kernel_library = kernel_class->parent();
   dart::Library& library =
       dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
   klass = library.LookupClassAllowPrivate(class_name);
 
   ASSERT(klass != Object::null());
   return klass;
 }
 
 
 dart::RawField* TranslationHelper::LookupFieldByKernelField(
-    Field* kernel_field) {
-  TreeNode* node = kernel_field->parent();
+    CanonicalName* kernel_field) {
+  ASSERT(kernel_field->IsField());
+  CanonicalName* enclosing = kernel_field->EnclosingName();
 
   dart::Class& klass = dart::Class::Handle(Z);
-  if (node->IsClass()) {
-    klass = LookupClassByKernelClass(Class::Cast(node)->canonical_name());
+  if (enclosing->IsLibrary()) {
+    dart::Library& library =
+        dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
+    klass = library.toplevel_class();
   } else {
-    ASSERT(node->IsLibrary());
-    dart::Library& library = dart::Library::Handle(
-        Z, LookupLibraryByKernelLibrary(Library::Cast(node)->canonical_name()));
-    klass = library.toplevel_class();
+    ASSERT(enclosing->IsClass());
+    klass = LookupClassByKernelClass(enclosing);
   }
   dart::RawField* field =
-      klass.LookupFieldAllowPrivate(DartSymbol(kernel_field->name()->string()));
+      klass.LookupFieldAllowPrivate(DartSymbol(kernel_field->name()));
   ASSERT(field != Object::null());
   return field;
 }
 
 
 dart::RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
-    Procedure* procedure) {
-  ASSERT(procedure->IsStatic());
+    CanonicalName* procedure) {
   const dart::String& procedure_name = DartProcedureName(procedure);
 
   // The parent is either a library or a class (in which case the procedure is a
   // static method).
-  TreeNode* parent = procedure->parent();
-  if (parent->IsClass()) {
-    dart::Class& klass = dart::Class::Handle(
-        Z, LookupClassByKernelClass(Class::Cast(parent)->canonical_name()));
+  CanonicalName* enclosing = procedure->EnclosingName();
+  if (enclosing->IsLibrary()) {
+    dart::Library& library =
+        dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
+    dart::RawFunction* function =
+        library.LookupFunctionAllowPrivate(procedure_name);
+    ASSERT(function != Object::null());
+    return function;
+  } else {
+    ASSERT(enclosing->IsClass());
+    dart::Class& klass =
+        dart::Class::Handle(Z, LookupClassByKernelClass(enclosing));
     dart::RawFunction* raw_function =
         klass.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(raw_function != Object::null());
 
     // TODO(27590): We can probably get rid of this after no longer using
     // core libraries from the source.
     dart::Function& function = dart::Function::ZoneHandle(Z, raw_function);
     if (function.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(klass, function);
       function = function.RedirectionTarget();
     }
     return function.raw();
-  } else {
-    ASSERT(parent->IsLibrary());
-    dart::Library& library = dart::Library::Handle(
-        Z,
-        LookupLibraryByKernelLibrary(Library::Cast(parent)->canonical_name()));
-    dart::RawFunction* function =
-        library.LookupFunctionAllowPrivate(procedure_name);
-    ASSERT(function != Object::null());
-    return function;
   }
 }
 
 
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
-    Constructor* constructor) {
-  Class* kernel_klass = Class::Cast(constructor->parent());
+    CanonicalName* constructor) {
+  ASSERT(constructor->IsConstructor());
   dart::Class& klass = dart::Class::Handle(
-      Z, LookupClassByKernelClass(kernel_klass->canonical_name()));
+      Z, LookupClassByKernelClass(constructor->EnclosingName()));
   return LookupConstructorByKernelConstructor(klass, constructor);
 }
 
 
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     const dart::Class& owner,
-    Constructor* constructor) {
+    CanonicalName* constructor) {
+  ASSERT(constructor->IsConstructor());
   dart::RawFunction* function =
       owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
   ASSERT(function != Object::null());
   return function;
 }
 
 
 dart::Type& TranslationHelper::GetCanonicalType(const dart::Class& klass) {
   ASSERT(!klass.IsNull());
   // Note that if cls is _Closure, the returned type will be _Closure,
@@ skipping 32 matching lines @@
 
   va_list args;
   va_start(args, format);
   Report::LongJumpV(prev_error, null_script, TokenPosition::kNoSource, format,
                     args);
   va_end(args);
   UNREACHABLE();
 }
 
 
-dart::String& TranslationHelper::ManglePrivateName(
-    CanonicalName* kernel_library,
-    dart::String* name_to_modify,
-    bool symbolize) {
+dart::String& TranslationHelper::ManglePrivateName(CanonicalName* parent,
+                                                   dart::String* name_to_modify,
+                                                   bool symbolize) {
   if (name_to_modify->Length() >= 1 && name_to_modify->CharAt(0) == '_') {
     const dart::Library& library =
-        dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
+        dart::Library::Handle(Z, LookupLibraryByKernelLibrary(parent));
     *name_to_modify = library.PrivateName(*name_to_modify);
   } else if (symbolize) {
     *name_to_modify = Symbols::New(thread_, *name_to_modify);
   }
   return *name_to_modify;
 }
 
 
 const Array& TranslationHelper::ArgumentNames(List<NamedExpression>* named) {
   if (named->length() == 0) return Array::ZoneHandle(Z);
@@ skipping 347 matching lines @@
   ASSERT(!function.IsNull());
 
   // Run the method and canonicalize the result.
   const Object& result = RunFunction(function, kernel_arguments, &receiver);
   result_ ^= result.raw();
   result_ = H.Canonicalize(result_);
 }
 
 
 void ConstantEvaluator::VisitStaticGet(StaticGet* node) {
-  Member* member = node->target();
-  if (member->IsField()) {
-    Field* kernel_field = Field::Cast(member);
+  CanonicalName* target = node->target();
+  if (target->IsField()) {
     const dart::Field& field =
-        dart::Field::Handle(Z, H.LookupFieldByKernelField(kernel_field));
+        dart::Field::Handle(Z, H.LookupFieldByKernelField(target));
     if (field.StaticValue() == Object::sentinel().raw() ||
         field.StaticValue() == Object::transition_sentinel().raw()) {
       field.EvaluateInitializer();
       result_ = field.StaticValue();
       result_ = H.Canonicalize(result_);
       field.SetStaticValue(result_, true);
     } else {
       result_ = field.StaticValue();
     }
-  } else if (member->IsProcedure()) {
-    Procedure* procedure = Procedure::Cast(member);
-    const Function& target = Function::ZoneHandle(
-        Z, H.LookupStaticMethodByKernelProcedure(procedure));
+  } else if (target->IsProcedure()) {
+    const Function& function =
+        Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
 
-    if (procedure->kind() == Procedure::kMethod) {
-      ASSERT(procedure->IsStatic());
+    if (target->IsMethod()) {
       Function& closure_function =
-          Function::ZoneHandle(Z, target.ImplicitClosureFunction());
-      closure_function.set_kernel_function(target.kernel_function());
+          Function::ZoneHandle(Z, function.ImplicitClosureFunction());
+      closure_function.set_kernel_function(function.kernel_function());
       result_ = closure_function.ImplicitStaticClosure();
       result_ = H.Canonicalize(result_);
-    } else if (procedure->kind() == Procedure::kGetter) {
+    } else if (target->IsGetter()) {
       UNIMPLEMENTED();
     } else {
       UNIMPLEMENTED();
     }
   }
 }
 
 
 void ConstantEvaluator::VisitVariableGet(VariableGet* node) {
   // When we see a [VariableGet] the corresponding [VariableDeclaration] must've
@@ skipping 87 matching lines @@
   }
 }
 
 
 void ConstantEvaluator::VisitNot(Not* node) {
   result_ ^= Bool::Get(!EvaluateBooleanExpression(node->expression())).raw();
 }
 
 
 void ConstantEvaluator::VisitPropertyGet(PropertyGet* node) {
-  const intptr_t kLengthLen = strlen("length");
+  const intptr_t kLengthLen = sizeof("length") - 1;
 
   String* string = node->name()->string();
   if ((string->size() == kLengthLen) &&
       (memcmp(string->buffer(), "length", kLengthLen) == 0)) {
     node->receiver()->AcceptExpressionVisitor(this);
     if (result_.IsString()) {
       const dart::String& str =
           dart::String::Handle(Z, dart::String::RawCast(result_.raw()));
       result_ = Integer::New(str.Length());
     } else {
@@ skipping 1004 matching lines @@
 
   instructions += StaticCall(TokenPosition::kNoSource, throw_function, 6);
   // Leave "result" on the stack since callers expect it to be there (even
   // though the function will result in an exception).
 
   return instructions;
 }
 
 
 dart::RawFunction* FlowGraphBuilder::LookupMethodByMember(
-    Member* target,
+    CanonicalName* target,
     const dart::String& method_name) {
-  Class* kernel_klass = Class::Cast(target->parent());
-  dart::Class& klass = dart::Class::Handle(
-      Z, H.LookupClassByKernelClass(kernel_klass->canonical_name()));
+  CanonicalName* kernel_class = target->EnclosingName();
+  dart::Class& klass =
+      dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
 
   dart::RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
   ASSERT(function != Object::null());
   return function;
 }
 
 
 LocalVariable* FlowGraphBuilder::MakeTemporary() {
   char name[64];
   intptr_t index = stack_->definition()->temp_index();
@@ skipping 138 matching lines @@
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   const dart::Function& function = parsed_function_->function();
 
   if (function.IsConstructorClosureFunction()) return NULL;
 
   dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
 
   Function& outermost_function = Function::Handle(Z);
   TreeNode* outermost_node = NULL;
-  Class* kernel_klass = NULL;
+  Class* kernel_class = NULL;
   DiscoverEnclosingElements(Z, function, &outermost_function, &outermost_node,
-                            &kernel_klass);
+                            &kernel_class);
 
   // Mark that we are using [klass]/[kernell_klass] as active class.  Resolving
   // of type parameters will get resolved via [kernell_klass] unless we are
   // nested inside a static factory in which case we will use [member].
-  ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
+  ActiveClassScope active_class_scope(&active_class_, kernel_class, &klass);
   Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
                        ? Member::Cast(outermost_node)
                        : NULL;
   ActiveMemberScope active_member(&active_class_, member);
 
   // The IR builder will create its own local variables and scopes, and it
   // will not need an AST.  The code generator will assume that there is a
   // local variable stack slot allocated for the current context and (I
   // think) that the runtime will expect it to be at a fixed offset which
   // requires allocating an unused expression temporary variable.
@@ skipping 96 matching lines @@
         body += StoreLocal(TokenPosition::kNoSource, parameter);
         body += Drop();
       }
     }
     body += Drop();  // The context.
   }
   if (constructor != NULL) {
     // TODO(27590): Currently the [VariableDeclaration]s from the
     // initializers will be visible inside the entire body of the constructor.
     // We should make a separate scope for them.
-    Class* kernel_klass = Class::Cast(constructor->parent());
-    body += TranslateInitializers(kernel_klass, &constructor->initializers());
+    Class* kernel_class = Class::Cast(constructor->parent());
+    body += TranslateInitializers(kernel_class, &constructor->initializers());
   }
 
   // The specification defines the result of `a == b` to be:
   //
   //   a) if either side is `null` then the result is `identical(a, b)`.
   //   b) else the result is `a.operator==(b)`
   //
   // For user-defined implementations of `operator==` we need therefore
   // implement the handling of a).
   //
@@ skipping 379 matching lines @@
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFieldAccessor(
     Field* kernel_field,
     LocalVariable* setter_value) {
   const dart::Function& function = parsed_function_->function();
 
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
-  dart::Field& field =
-      dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
+  dart::Field& field = dart::Field::ZoneHandle(
+      Z, H.LookupFieldByKernelField(kernel_field->canonical_name()));
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
 
   Fragment body(normal_entry);
   if (is_setter) {
     if (is_method) {
       body += LoadLocal(scopes_->this_variable);
       body += LoadLocal(setter_value);
@@ skipping 525 matching lines @@
   return new (Z) JoinEntryInstr(AllocateBlockId(), try_index);
 }
 
 
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
   return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
 Fragment FlowGraphBuilder::TranslateInitializers(
-    Class* kernel_klass,
+    Class* kernel_class,
     List<Initializer>* initializers) {
   Fragment instructions;
 
   // These come from:
   //   class A {
   //     var x = (expr);
   //   }
-  for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
-    Field* kernel_field = kernel_klass->fields()[i];
+  for (intptr_t i = 0; i < kernel_class->fields().length(); i++) {
+    Field* kernel_field = kernel_class->fields()[i];
     Expression* init = kernel_field->initializer();
     if (!kernel_field->IsStatic() && init != NULL) {
-      dart::Field& field =
-          dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
+      dart::Field& field = dart::Field::ZoneHandle(
+          Z, H.LookupFieldByKernelField(kernel_field->canonical_name()));
 
       EnterScope(kernel_field);
       instructions += LoadLocal(scopes_->this_variable);
       instructions += TranslateExpression(init);
       instructions += StoreInstanceFieldGuarded(field, true);
       ExitScope(kernel_field);
     }
   }
 
   // These to come from:
@@ skipping 374 matching lines @@
 
 
 void DartTypeTranslator::VisitInterfaceType(InterfaceType* node) {
   // NOTE: That an interface type like `T<A, B>` is considered to be
   // malformed iff `T` is malformed.
   //   => We therefore ignore errors in `A` or `B`.
   const TypeArguments& type_arguments = TranslateTypeArguments(
       node->type_arguments().raw_array(), node->type_arguments().length());
 
 
-  dart::Object& klass = dart::Object::Handle(
-      Z, H.LookupClassByKernelClass(node->class_reference()));
+  dart::Object& klass =
+      dart::Object::Handle(Z, H.LookupClassByKernelClass(node->klass()));
   result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
   if (finalize_) {
     ASSERT(active_class_->klass != NULL);
     result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_);
   }
 }
 
 
 void DartTypeTranslator::VisitDynamicType(DynamicType* node) {
   result_ = Object::dynamic_type().raw();
@@ skipping 102 matching lines @@
     instructions = DebugStepCheck(node->position()) + instructions;
   }
   instructions += CheckVariableTypeInCheckedMode(node->variable());
   instructions +=
       StoreLocal(node->position(), LookupVariable(node->variable()));
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
-  Member* target = node->target();
+  CanonicalName* target = node->target();
   if (target->IsField()) {
-    Field* kernel_field = Field::Cast(target);
     const dart::Field& field =
-        dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
+        dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     if (field.is_const()) {
       fragment_ = Constant(constant_evaluator_.EvaluateExpression(node));
     } else {
       const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
-      const dart::String& getter_name = H.DartGetterName(kernel_field->name());
+      const dart::String& getter_name = H.DartGetterName(target);
       const Function& getter =
           Function::ZoneHandle(Z, owner.LookupStaticFunction(getter_name));
       if (getter.IsNull() || !field.has_initializer()) {
         Fragment instructions = Constant(field);
         fragment_ = instructions + LoadStaticField();
       } else {
         fragment_ = StaticCall(node->position(), getter, 0);
       }
     }
   } else {
-    Procedure* procedure = Procedure::Cast(target);
-    const Function& target = Function::ZoneHandle(
-        Z, H.LookupStaticMethodByKernelProcedure(procedure));
+    const Function& function =
+        Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
 
-    if (procedure->kind() == Procedure::kGetter) {
-      fragment_ = StaticCall(node->position(), target, 0);
-    } else if (procedure->kind() == Procedure::kMethod) {
-      ASSERT(procedure->IsStatic());
+    if (target->IsGetter()) {
+      fragment_ = StaticCall(node->position(), function, 0);
+    } else if (target->IsMethod()) {
       fragment_ = Constant(constant_evaluator_.EvaluateExpression(node));
     } else {
       UNIMPLEMENTED();
     }
   }
 }
 
 
 void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
-  Member* target = node->target();
+  CanonicalName* target = node->target();
   if (target->IsField()) {
-    Field* kernel_field = Field::Cast(target);
     const dart::Field& field =
-        dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
+        dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
     Fragment instructions = TranslateExpression(node->expression());
     if (NeedsDebugStepCheck(stack_, node->position())) {
       instructions = DebugStepCheck(node->position()) + instructions;
     }
     instructions += CheckAssignableInCheckedMode(
         dst_type, dart::String::ZoneHandle(Z, field.name()));
     LocalVariable* variable = MakeTemporary();
     instructions += LoadLocal(variable);
     fragment_ = instructions + StoreStaticField(node->position(), field);
   } else {
     ASSERT(target->IsProcedure());
 
     // Evaluate the expression on the right hand side.
     Fragment instructions = TranslateExpression(node->expression());
     LocalVariable* variable = MakeTemporary();
 
     // Prepare argument.
     instructions += LoadLocal(variable);
     instructions += PushArgument();
 
     // Invoke the setter function.
-    Procedure* procedure = Procedure::Cast(target);
-    const Function& target = Function::ZoneHandle(
-        Z, H.LookupStaticMethodByKernelProcedure(procedure));
-    instructions += StaticCall(node->position(), target, 1);
+    const Function& function =
+        Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
+    instructions += StaticCall(node->position(), function, 1);
 
     // Drop the unused result & leave the stored value on the stack.
     fragment_ = instructions + Drop();
   }
 }
 
 
 void FlowGraphBuilder::VisitPropertyGet(PropertyGet* node) {
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
@@ skipping 13 matching lines @@
   instructions += PushArgument();
 
   const dart::String& setter_name = H.DartSetterName(node->name());
   instructions += InstanceCall(node->position(), setter_name, Token::kSET, 2);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
   Function& target = Function::ZoneHandle(Z);
-  if (node->target()->IsProcedure()) {
-    Procedure* kernel_procedure = Procedure::Cast(node->target());
-    Name* kernel_name = kernel_procedure->name();
-    if (kernel_procedure->kind() == Procedure::kGetter) {
-      target =
-          LookupMethodByMember(kernel_procedure, H.DartGetterName(kernel_name));
+  CanonicalName* kernel_name = node->target();
+  if (kernel_name->IsProcedure()) {
+    if (kernel_name->IsGetter()) {
+      target = LookupMethodByMember(kernel_name, H.DartGetterName(kernel_name));
     } else {
-      target =
-          LookupMethodByMember(kernel_procedure, H.DartMethodName(kernel_name));
+      target = LookupMethodByMember(kernel_name, H.DartMethodName(kernel_name));
       target = target.ImplicitClosureFunction();
       ASSERT(!target.IsNull());
       fragment_ = BuildImplicitClosureCreation(target);
       return;
     }
   } else {
-    ASSERT(node->target()->IsField());
-    const dart::String& getter_name = H.DartGetterName(node->target()->name());
-    target = LookupMethodByMember(node->target(), getter_name);
+    ASSERT(kernel_name->IsField());
+    const dart::String& getter_name = H.DartGetterName(kernel_name);
+    target = LookupMethodByMember(kernel_name, getter_name);
     ASSERT(target.IsGetterFunction() || target.IsImplicitGetterFunction());
   }
 
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   fragment_ = instructions + StaticCall(node->position(), target, 1);
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertySet(DirectPropertySet* node) {
-  const dart::String& method_name = H.DartSetterName(node->target()->name());
+  const dart::String& method_name = H.DartSetterName(node->target());
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(node->target(), method_name));
   ASSERT(target.IsSetterFunction() || target.IsImplicitSetterFunction());
 
   Fragment instructions(NullConstant());
   LocalVariable* value = MakeTemporary();
   instructions += TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateExpression(node->value());
   instructions += StoreLocal(TokenPosition::kNoSource, value);
@@ skipping 171 matching lines @@
 }
 
 
 void FlowGraphBuilder::VisitConstructorInvocation(ConstructorInvocation* node) {
   if (node->is_const()) {
     fragment_ =
         Constant(constant_evaluator_.EvaluateConstructorInvocation(node));
     return;
   }
 
-  Class* kernel_class = Class::Cast(node->target()->parent());
-
   dart::Class& klass = dart::Class::ZoneHandle(
-      Z, H.LookupClassByKernelClass(kernel_class->canonical_name()));
+      Z, H.LookupClassByKernelClass(node->target()->EnclosingName()));
 
   Fragment instructions;
 
   // Check for malbounded-ness of type.
   if (I->type_checks()) {
     List<DartType>& kernel_type_arguments = node->arguments()->types();
     const TypeArguments& type_arguments = T.TranslateInstantiatedTypeArguments(
         klass, kernel_type_arguments.raw_array(),
         kernel_type_arguments.length());
 
@@ skipping 1519 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)