Do not qualify with dart:: except where necessary

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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 53 matching lines @@
 Fragment operator<<(const Fragment& fragment, Instruction* next) {
   Fragment result = fragment;
   result <<= next;
   return result;
 }
 
 intptr_t ActiveClass::MemberTypeParameterCount(Zone* zone) {
   ASSERT(member != NULL);
   if (member->IsFactory()) {
     TypeArguments& class_types =
-        dart::TypeArguments::Handle(zone, klass->type_parameters());
+        TypeArguments::Handle(zone, klass->type_parameters());
     return class_types.Length();
   } else if (member->IsMethodExtractor()) {
     Function& extracted =
         Function::Handle(zone, member->extracted_method_closure());
     TypeArguments& function_types =
-        dart::TypeArguments::Handle(zone, extracted.type_parameters());
+        TypeArguments::Handle(zone, extracted.type_parameters());
     return function_types.Length();
   } else {
     TypeArguments& function_types =
-        dart::TypeArguments::Handle(zone, member->type_parameters());
+        TypeArguments::Handle(zone, member->type_parameters());
     return function_types.Length();
   }
 }
 
 TranslationHelper::TranslationHelper(Thread* thread)
     : thread_(thread),
       zone_(thread->zone()),
       isolate_(thread->isolate()),
       allocation_space_(thread->IsMutatorThread() ? Heap::kNew : Heap::kOld),
       string_offsets_(TypedData::Handle(Z)),
       string_data_(TypedData::Handle(Z)),
       canonical_names_(TypedData::Handle(Z)) {}
 
 TranslationHelper::TranslationHelper(Thread* thread,
-                                     dart::RawTypedData* string_offsets,
-                                     dart::RawTypedData* string_data,
-                                     dart::RawTypedData* canonical_names)
+                                     RawTypedData* string_offsets,
+                                     RawTypedData* string_data,
+                                     RawTypedData* canonical_names)
     : thread_(thread),
       zone_(thread->zone()),
       isolate_(thread->isolate()),
       allocation_space_(Heap::kNew),
       string_offsets_(TypedData::Handle(Z, string_offsets)),
       string_data_(TypedData::Handle(Z, string_data)),
       canonical_names_(TypedData::Handle(Z, canonical_names)) {
   ASSERT(thread->IsMutatorThread());
 }
 
@@ skipping 183 matching lines @@
   if (instance.IsNull()) return instance.raw();
 
   const char* error_str = NULL;
   RawInstance* result = instance.CheckAndCanonicalize(thread(), &error_str);
   if (result == Object::null()) {
     ReportError("Invalid const object %s", error_str);
   }
   return result;
 }
 
-const dart::String& TranslationHelper::DartString(const char* content,
-                                                  Heap::Space space) {
-  return dart::String::ZoneHandle(Z, dart::String::New(content, space));
+const String& TranslationHelper::DartString(const char* content,
+                                            Heap::Space space) {
+  return String::ZoneHandle(Z, String::New(content, space));
 }
 
-dart::String& TranslationHelper::DartString(StringIndex string_index,
-                                            Heap::Space space) {
+String& TranslationHelper::DartString(StringIndex string_index,
+                                      Heap::Space space) {
   intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
   }
-  return dart::String::ZoneHandle(
-      Z, dart::String::FromUTF8(buffer, length, space));
+  return String::ZoneHandle(Z, String::FromUTF8(buffer, length, space));
 }
 
-dart::String& TranslationHelper::DartString(const uint8_t* utf8_array,
-                                            intptr_t len,
-                                            Heap::Space space) {
-  return dart::String::ZoneHandle(
-      Z, dart::String::FromUTF8(utf8_array, len, space));
+String& TranslationHelper::DartString(const uint8_t* utf8_array,
+                                      intptr_t len,
+                                      Heap::Space space) {
+  return String::ZoneHandle(Z, String::FromUTF8(utf8_array, len, space));
 }
 
-const dart::String& TranslationHelper::DartSymbol(const char* content) const {
-  return dart::String::ZoneHandle(Z, Symbols::New(thread_, content));
+const String& TranslationHelper::DartSymbol(const char* content) const {
+  return String::ZoneHandle(Z, Symbols::New(thread_, content));
 }
 
-dart::String& TranslationHelper::DartSymbol(StringIndex string_index) const {
+String& TranslationHelper::DartSymbol(StringIndex string_index) const {
   intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
   }
-  return dart::String::ZoneHandle(Z,
-                                  Symbols::FromUTF8(thread_, buffer, length));
+  return String::ZoneHandle(Z, Symbols::FromUTF8(thread_, buffer, length));
 }
 
-dart::String& TranslationHelper::DartSymbol(const uint8_t* utf8_array,
-                                            intptr_t len) const {
-  return dart::String::ZoneHandle(Z,
-                                  Symbols::FromUTF8(thread_, utf8_array, len));
+String& TranslationHelper::DartSymbol(const uint8_t* utf8_array,
+                                      intptr_t len) const {
+  return String::ZoneHandle(Z, Symbols::FromUTF8(thread_, utf8_array, len));
 }
 
-const dart::String& TranslationHelper::DartClassName(NameIndex kernel_class) {
+const String& TranslationHelper::DartClassName(NameIndex kernel_class) {
   ASSERT(IsClass(kernel_class));
-  dart::String& name = DartString(CanonicalNameString(kernel_class));
+  String& name = DartString(CanonicalNameString(kernel_class));
   return ManglePrivateName(CanonicalNameParent(kernel_class), &name);
 }
 
-const dart::String& TranslationHelper::DartConstructorName(
-    NameIndex constructor) {
+const String& TranslationHelper::DartConstructorName(NameIndex constructor) {
   ASSERT(IsConstructor(constructor));
   return DartFactoryName(constructor);
 }
 
-const dart::String& TranslationHelper::DartProcedureName(NameIndex procedure) {
+const String& TranslationHelper::DartProcedureName(NameIndex procedure) {
   ASSERT(IsProcedure(procedure));
   if (IsSetter(procedure)) {
     return DartSetterName(procedure);
   } else if (IsGetter(procedure)) {
     return DartGetterName(procedure);
   } else if (IsFactory(procedure)) {
     return DartFactoryName(procedure);
   } else {
     return DartMethodName(procedure);
   }
 }
 
-const dart::String& TranslationHelper::DartSetterName(NameIndex setter) {
+const String& TranslationHelper::DartSetterName(NameIndex setter) {
   return DartSetterName(CanonicalNameParent(setter),
                         CanonicalNameString(setter));
 }
 
-const dart::String& TranslationHelper::DartSetterName(NameIndex parent,
-                                                      StringIndex setter) {
+const String& TranslationHelper::DartSetterName(NameIndex parent,
+                                                StringIndex 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.
   intptr_t size = StringSize(setter);
   ASSERT(size > 0);
   if (CharacterAt(setter, size - 1) == '=') {
     --size;
   }
   uint8_t* buffer = Z->Alloc<uint8_t>(size);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(setter)), size);
   }
-  dart::String& name = dart::String::ZoneHandle(
-      Z, dart::String::FromUTF8(buffer, size, allocation_space_));
+  String& name =
+      String::ZoneHandle(Z, String::FromUTF8(buffer, size, allocation_space_));
   ManglePrivateName(parent, &name, false);
-  name = dart::Field::SetterSymbol(name);
+  name = Field::SetterSymbol(name);
   return name;
 }
 
-const dart::String& TranslationHelper::DartGetterName(NameIndex getter) {
+const String& TranslationHelper::DartGetterName(NameIndex getter) {
   return DartGetterName(CanonicalNameParent(getter),
                         CanonicalNameString(getter));
 }
 
-const dart::String& TranslationHelper::DartGetterName(NameIndex parent,
-                                                      StringIndex getter) {
-  dart::String& name = DartString(getter);
+const String& TranslationHelper::DartGetterName(NameIndex parent,
+                                                StringIndex getter) {
+  String& name = DartString(getter);
   ManglePrivateName(parent, &name, false);
-  name = dart::Field::GetterSymbol(name);
+  name = Field::GetterSymbol(name);
   return name;
 }
 
-const dart::String& TranslationHelper::DartFieldName(NameIndex parent,
-                                                     StringIndex field) {
-  dart::String& name = DartString(field);
+const String& TranslationHelper::DartFieldName(NameIndex parent,
+                                               StringIndex field) {
+  String& name = DartString(field);
   return ManglePrivateName(parent, &name);
 }
 
-const dart::String& TranslationHelper::DartMethodName(NameIndex method) {
+const String& TranslationHelper::DartMethodName(NameIndex method) {
   return DartMethodName(CanonicalNameParent(method),
                         CanonicalNameString(method));
 }
 
-const dart::String& TranslationHelper::DartMethodName(NameIndex parent,
-                                                      StringIndex method) {
-  dart::String& name = DartString(method);
+const String& TranslationHelper::DartMethodName(NameIndex parent,
+                                                StringIndex method) {
+  String& name = DartString(method);
   return ManglePrivateName(parent, &name);
 }
 
-const dart::String& TranslationHelper::DartFactoryName(NameIndex factory) {
+const String& TranslationHelper::DartFactoryName(NameIndex factory) {
   ASSERT(IsConstructor(factory) || IsFactory(factory));
-  GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
+  GrowableHandlePtrArray<const String> pieces(Z, 3);
   pieces.Add(DartClassName(EnclosingName(factory)));
   pieces.Add(Symbols::Dot());
   // [DartMethodName] will mangle the name.
   pieces.Add(DartMethodName(factory));
-  return dart::String::ZoneHandle(Z, Symbols::FromConcatAll(thread_, pieces));
+  return String::ZoneHandle(Z, Symbols::FromConcatAll(thread_, pieces));
 }
 
 RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
     NameIndex kernel_library) {
   // We only use the string and don't rely on having any particular parent.
   // This ASSERT is just a sanity check.
   ASSERT(IsLibrary(kernel_library) ||
          IsAdministrative(CanonicalNameParent(kernel_library)));
-  const dart::String& library_name =
-      DartSymbol(CanonicalNameString(kernel_library));
+  const String& library_name = DartSymbol(CanonicalNameString(kernel_library));
   ASSERT(!library_name.IsNull());
-  RawLibrary* library = dart::Library::LookupLibrary(thread_, library_name);
+  RawLibrary* library = Library::LookupLibrary(thread_, library_name);
   ASSERT(library != Object::null());
   return library;
 }
 
 RawClass* TranslationHelper::LookupClassByKernelClass(NameIndex kernel_class) {
   ASSERT(IsClass(kernel_class));
-  const dart::String& class_name = DartClassName(kernel_class);
+  const String& class_name = DartClassName(kernel_class);
   NameIndex kernel_library = CanonicalNameParent(kernel_class);
-  dart::Library& library =
-      dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
+  Library& library =
+      Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
   RawClass* klass = library.LookupClassAllowPrivate(class_name);
 
   ASSERT(klass != Object::null());
   return klass;
 }
 
 RawField* TranslationHelper::LookupFieldByKernelField(NameIndex kernel_field) {
   ASSERT(IsField(kernel_field));
   NameIndex enclosing = EnclosingName(kernel_field);
 
-  dart::Class& klass = dart::Class::Handle(Z);
+  Class& klass = Class::Handle(Z);
   if (IsLibrary(enclosing)) {
-    dart::Library& library =
-        dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
+    Library& library =
+        Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
     klass = library.toplevel_class();
   } else {
     ASSERT(IsClass(enclosing));
     klass = LookupClassByKernelClass(enclosing);
   }
   RawField* field = klass.LookupFieldAllowPrivate(
       DartSymbol(CanonicalNameString(kernel_field)));
   ASSERT(field != Object::null());
   return field;
 }
 
 RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
     NameIndex procedure) {
-  const dart::String& procedure_name = DartProcedureName(procedure);
+  const String& procedure_name = DartProcedureName(procedure);
 
   // The parent is either a library or a class (in which case the procedure is a
   // static method).
   NameIndex enclosing = EnclosingName(procedure);
   if (IsLibrary(enclosing)) {
-    dart::Library& library =
-        dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
+    Library& library =
+        Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
     RawFunction* function = library.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(function != Object::null());
     return function;
   } else {
     ASSERT(IsClass(enclosing));
-    dart::Class& klass =
-        dart::Class::Handle(Z, LookupClassByKernelClass(enclosing));
+    Class& klass = Class::Handle(Z, LookupClassByKernelClass(enclosing));
     Function& function = Function::ZoneHandle(
         Z, klass.LookupFunctionAllowPrivate(procedure_name));
     ASSERT(!function.IsNull());
 
     // TODO(27590): We can probably get rid of this after no longer using
     // core libraries from the source.
     if (function.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(klass, function);
       function = function.RedirectionTarget();
     }
     return function.raw();
   }
 }
 
 RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     NameIndex constructor) {
   ASSERT(IsConstructor(constructor));
-  dart::Class& klass = dart::Class::Handle(
-      Z, LookupClassByKernelClass(EnclosingName(constructor)));
+  Class& klass =
+      Class::Handle(Z, LookupClassByKernelClass(EnclosingName(constructor)));
   return LookupConstructorByKernelConstructor(klass, constructor);
 }
 
 RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
-    const dart::Class& owner,
+    const Class& owner,
     NameIndex constructor) {
   ASSERT(IsConstructor(constructor));
   RawFunction* function =
       owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
   ASSERT(function != Object::null());
   return function;
 }
 
-dart::Type& TranslationHelper::GetCanonicalType(const dart::Class& klass) {
+Type& TranslationHelper::GetCanonicalType(const Class& klass) {
   ASSERT(!klass.IsNull());
   // Note that if cls is _Closure, the returned type will be _Closure,
   // and not the signature type.
   Type& type = Type::ZoneHandle(Z, klass.CanonicalType());
   if (!type.IsNull()) {
     return type;
   }
   type = Type::New(klass, TypeArguments::Handle(Z, klass.type_parameters()),
                    klass.token_pos());
   if (klass.is_type_finalized()) {
@@ skipping 21 matching lines @@
   const Script& null_script = Script::Handle(Z);
 
   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(NameIndex parent,
-                                                   dart::String* name_to_modify,
-                                                   bool symbolize) {
+String& TranslationHelper::ManglePrivateName(NameIndex parent,
+                                             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(parent));
+    const Library& library =
+        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;
 }
 
 FlowGraphBuilder::FlowGraphBuilder(
     intptr_t kernel_offset,
     ParsedFunction* parsed_function,
@@ skipping 174 matching lines @@
       function = function.parent_function();
     }
     ASSERT(function.IsFactory());
 #endif
     instructions += LoadLocal(scopes_->type_arguments_variable);
   } else if (scopes_->this_variable != NULL &&
              active_class_.ClassTypeParameterCount(Z) > 0) {
     ASSERT(!parsed_function_->function().IsFactory());
     intptr_t type_arguments_field_offset =
         active_class_.klass->type_arguments_field_offset();
-    ASSERT(type_arguments_field_offset != dart::Class::kNoTypeArguments);
+    ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
     instructions += LoadLocal(scopes_->this_variable);
     instructions += LoadField(type_arguments_field_offset);
   } else {
     instructions += NullConstant();
   }
   return instructions;
 }
 
 // TODO(30455): Kernel generic methods undone. This seems to work for static
@@ skipping 71 matching lines @@
 }
 
 Fragment FlowGraphBuilder::AllocateContext(intptr_t size) {
   AllocateContextInstr* allocate =
       new (Z) AllocateContextInstr(TokenPosition::kNoSource, size);
   Push(allocate);
   return Fragment(allocate);
 }
 
 Fragment FlowGraphBuilder::AllocateObject(TokenPosition position,
-                                          const dart::Class& klass,
+                                          const Class& klass,
                                           intptr_t argument_count) {
   ArgumentArray arguments = GetArguments(argument_count);
   AllocateObjectInstr* allocate =
       new (Z) AllocateObjectInstr(position, klass, arguments);
   Push(allocate);
   return Fragment(allocate);
 }
 
-Fragment FlowGraphBuilder::AllocateObject(const dart::Class& klass,
+Fragment FlowGraphBuilder::AllocateObject(const Class& klass,
                                           const Function& closure_function) {
   ArgumentArray arguments = new (Z) ZoneGrowableArray<PushArgumentInstr*>(Z, 0);
   AllocateObjectInstr* allocate =
       new (Z) AllocateObjectInstr(TokenPosition::kNoSource, klass, arguments);
   allocate->set_closure_function(closure_function);
   Push(allocate);
   return Fragment(allocate);
 }
 
 Fragment FlowGraphBuilder::BooleanNegate() {
@@ skipping 155 matching lines @@
 Fragment FlowGraphBuilder::Goto(JoinEntryInstr* destination) {
   return Fragment(new (Z) GotoInstr(destination, GetNextDeoptId())).closed();
 }
 
 Fragment FlowGraphBuilder::IntConstant(int64_t value) {
   return Fragment(
       Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld))));
 }
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
-                                        const dart::String& name,
+                                        const String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
                                         intptr_t checked_argument_count) {
   const intptr_t kTypeArgsLen = 0;
   return InstanceCall(position, name, kind, kTypeArgsLen, argument_count,
                       Array::null_array(), checked_argument_count);
 }
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
-                                        const dart::String& name,
+                                        const String& name,
                                         Token::Kind kind,
                                         intptr_t type_args_len,
                                         intptr_t argument_count,
                                         const Array& argument_names,
                                         intptr_t checked_argument_count) {
   const intptr_t total_count = argument_count + (type_args_len > 0 ? 1 : 0);
   ArgumentArray arguments = GetArguments(total_count);
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       position, name, kind, arguments, type_args_len, argument_names,
       checked_argument_count, ic_data_array_, GetNextDeoptId());
@@ skipping 44 matching lines @@
 
   return instructions;
 }
 
 Fragment FlowGraphBuilder::LoadClassId() {
   LoadClassIdInstr* load = new (Z) LoadClassIdInstr(Pop());
   Push(load);
   return Fragment(load);
 }
 
-const dart::Field& MayCloneField(Zone* zone, const dart::Field& field) {
+const Field& MayCloneField(Zone* zone, const Field& field) {
   if ((Compiler::IsBackgroundCompilation() ||
        FLAG_force_clone_compiler_objects) &&
       field.IsOriginal()) {
-    return dart::Field::ZoneHandle(zone, field.CloneFromOriginal());
+    return Field::ZoneHandle(zone, field.CloneFromOriginal());
   } else {
     ASSERT(field.IsZoneHandle());
     return field;
   }
 }
 
-Fragment FlowGraphBuilder::LoadField(const dart::Field& field) {
+Fragment FlowGraphBuilder::LoadField(const Field& field) {
   LoadFieldInstr* load =
       new (Z) LoadFieldInstr(Pop(), &MayCloneField(Z, field),
                              AbstractType::ZoneHandle(Z, field.type()),
                              TokenPosition::kNoSource, parsed_function_);
   Push(load);
   return Fragment(load);
 }
 
 Fragment FlowGraphBuilder::LoadField(intptr_t offset, intptr_t class_id) {
   LoadFieldInstr* load = new (Z) LoadFieldInstr(
@@ skipping 24 matching lines @@
     instructions += LoadField(Context::variable_offset(variable->index()));
   } else {
     LoadLocalInstr* load =
         new (Z) LoadLocalInstr(*variable, TokenPosition::kNoSource);
     instructions <<= load;
     Push(load);
   }
   return instructions;
 }
 
-Fragment FlowGraphBuilder::InitStaticField(const dart::Field& field) {
+Fragment FlowGraphBuilder::InitStaticField(const Field& field) {
   InitStaticFieldInstr* init = new (Z)
       InitStaticFieldInstr(Pop(), MayCloneField(Z, field), GetNextDeoptId());
   return Fragment(init);
 }
 
 Fragment FlowGraphBuilder::LoadStaticField() {
   LoadStaticFieldInstr* load =
       new (Z) LoadStaticFieldInstr(Pop(), TokenPosition::kNoSource);
   Push(load);
   return Fragment(load);
 }
 
 Fragment FlowGraphBuilder::NullConstant() {
   return Constant(Instance::ZoneHandle(Z, Instance::null()));
 }
 
-Fragment FlowGraphBuilder::NativeCall(const dart::String* name,
+Fragment FlowGraphBuilder::NativeCall(const String* name,
                                       const Function* function) {
   InlineBailout("kernel::FlowGraphBuilder::NativeCall");
   NativeCallInstr* call = new (Z) NativeCallInstr(
       name, function, FLAG_link_natives_lazily, TokenPosition::kNoSource);
   Push(call);
   return Fragment(call);
 }
 
 Fragment FlowGraphBuilder::PushArgument() {
   PushArgumentInstr* argument = new (Z) PushArgumentInstr(Pop());
@@ skipping 44 matching lines @@
   return StaticCall(position, target, argument_count, Array::null_array());
 }
 
 static intptr_t GetResultCidOfListFactory(Zone* zone,
                                           const Function& function,
                                           intptr_t argument_count) {
   if (!function.IsFactory()) {
     return kDynamicCid;
   }
 
-  const dart::Class& owner = dart::Class::Handle(zone, function.Owner());
-  if ((owner.library() != dart::Library::CoreLibrary()) &&
-      (owner.library() != dart::Library::TypedDataLibrary())) {
+  const Class& owner = Class::Handle(zone, function.Owner());
+  if ((owner.library() != Library::CoreLibrary()) &&
+      (owner.library() != Library::TypedDataLibrary())) {
     return kDynamicCid;
   }
 
   if ((owner.Name() == Symbols::List().raw()) &&
       (function.name() == Symbols::ListFactory().raw())) {
     ASSERT(argument_count == 1 || argument_count == 2);
     return (argument_count == 1) ? kGrowableObjectArrayCid : kArrayCid;
   }
   return FactoryRecognizer::ResultCid(function);
 }
@@ skipping 26 matching lines @@
       value->BindsToConstant() ? kNoStoreBarrier : kEmitStoreBarrier;
   StoreIndexedInstr* store = new (Z) StoreIndexedInstr(
       Pop(),  // Array.
       index, value, emit_store_barrier, Instance::ElementSizeFor(class_id),
       class_id, kAlignedAccess, Thread::kNoDeoptId, TokenPosition::kNoSource);
   Push(store);
   return Fragment(store);
 }
 
 Fragment FlowGraphBuilder::StoreInstanceField(
-    const dart::Field& field,
+    const Field& field,
     bool is_initialization_store,
     StoreBarrierType emit_store_barrier) {
   Fragment instructions;
 
   const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
   instructions += CheckAssignableInCheckedMode(
-      dst_type, dart::String::ZoneHandle(Z, field.name()));
+      dst_type, String::ZoneHandle(Z, field.name()));
 
   Value* value = Pop();
   if (value->BindsToConstant()) {
     emit_store_barrier = kNoStoreBarrier;
   }
 
   StoreInstanceFieldInstr* store = new (Z)
       StoreInstanceFieldInstr(MayCloneField(Z, field), Pop(), value,
                               emit_store_barrier, TokenPosition::kNoSource);
   store->set_is_initialization(is_initialization_store);
   instructions <<= store;
 
   return instructions;
 }
 
 Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(
-    const dart::Field& field,
+    const Field& field,
     bool is_initialization_store) {
   Fragment instructions;
-  const dart::Field& field_clone = MayCloneField(Z, field);
+  const Field& field_clone = MayCloneField(Z, field);
   if (I->use_field_guards()) {
     LocalVariable* store_expression = MakeTemporary();
     instructions += LoadLocal(store_expression);
     instructions += GuardFieldClass(field_clone, GetNextDeoptId());
     instructions += LoadLocal(store_expression);
     instructions += GuardFieldLength(field_clone, GetNextDeoptId());
   }
   instructions += StoreInstanceField(field_clone, is_initialization_store);
   return instructions;
 }
@@ skipping 24 matching lines @@
     Value* value = Pop();
     StoreLocalInstr* store =
         new (Z) StoreLocalInstr(*variable, value, position);
     instructions <<= store;
     Push(store);
   }
   return instructions;
 }
 
 Fragment FlowGraphBuilder::StoreStaticField(TokenPosition position,
-                                            const dart::Field& field) {
+                                            const Field& field) {
   return Fragment(
       new (Z) StoreStaticFieldInstr(MayCloneField(Z, field), Pop(), position));
 }
 
 Fragment FlowGraphBuilder::StringInterpolate(TokenPosition position) {
   Value* array = Pop();
   StringInterpolateInstr* interpolate =
       new (Z) StringInterpolateInstr(array, position, GetNextDeoptId());
   Push(interpolate);
   return Fragment(interpolate);
 }
 
 Fragment FlowGraphBuilder::StringInterpolateSingle(TokenPosition position) {
   const int kTypeArgsLen = 0;
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Object::null_array();
-  const dart::Class& cls = dart::Class::Handle(
-      dart::Library::LookupCoreClass(Symbols::StringBase()));
+  const Class& cls =
+      Class::Handle(Library::LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
   const Function& function = Function::ZoneHandle(
-      Z,
-      Resolver::ResolveStatic(
-          cls, dart::Library::PrivateCoreLibName(Symbols::InterpolateSingle()),
-          kTypeArgsLen, kNumberOfArguments, kNoArgumentNames));
+      Z, Resolver::ResolveStatic(
+             cls, Library::PrivateCoreLibName(Symbols::InterpolateSingle()),
+             kTypeArgsLen, kNumberOfArguments, kNoArgumentNames));
   Fragment instructions;
   instructions += PushArgument();
   instructions += StaticCall(position, function, 1);
   return instructions;
 }
 
 Fragment FlowGraphBuilder::ThrowTypeError() {
-  const dart::Class& klass = dart::Class::ZoneHandle(
-      Z, dart::Library::LookupCoreClass(Symbols::TypeError()));
+  const Class& klass =
+      Class::ZoneHandle(Z, Library::LookupCoreClass(Symbols::TypeError()));
   ASSERT(!klass.IsNull());
   const Function& constructor = Function::ZoneHandle(
       Z,
       klass.LookupConstructorAllowPrivate(H.DartSymbol("_TypeError._create")));
   ASSERT(!constructor.IsNull());
 
-  const dart::String& url = H.DartString(
+  const String& url = H.DartString(
       parsed_function_->function().ToLibNamePrefixedQualifiedCString(),
       Heap::kOld);
 
   Fragment instructions;
 
   // Create instance of _FallThroughError
   instructions += AllocateObject(TokenPosition::kNoSource, klass, 0);
   LocalVariable* instance = MakeTemporary();
 
   // Call _TypeError._create constructor.
@@ skipping 16 matching lines @@
   instructions += Drop();
 
   // Throw the exception
   instructions += PushArgument();
   instructions += ThrowException(TokenPosition::kNoSource);
 
   return instructions;
 }
 
 Fragment FlowGraphBuilder::ThrowNoSuchMethodError() {
-  const dart::Class& klass = dart::Class::ZoneHandle(
-      Z, dart::Library::LookupCoreClass(Symbols::NoSuchMethodError()));
+  const Class& klass = Class::ZoneHandle(
+      Z, Library::LookupCoreClass(Symbols::NoSuchMethodError()));
   ASSERT(!klass.IsNull());
   const Function& throw_function = Function::ZoneHandle(
       Z, klass.LookupStaticFunctionAllowPrivate(Symbols::ThrowNew()));
   ASSERT(!throw_function.IsNull());
 
   Fragment instructions;
 
   // Call NoSuchMethodError._throwNew static function.
   instructions += NullConstant();
   instructions += PushArgument();  // receiver
@@ skipping 13 matching lines @@
   instructions += NullConstant();
   instructions += PushArgument();  // existingArgumentNames
 
   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;
 }
 
-RawFunction* FlowGraphBuilder::LookupMethodByMember(
-    NameIndex target,
-    const dart::String& method_name) {
+RawFunction* FlowGraphBuilder::LookupMethodByMember(NameIndex target,
+                                                    const String& method_name) {
   NameIndex kernel_class = H.EnclosingName(target);
-  dart::Class& klass =
-      dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
+  Class& klass = Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
 
   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();
   OS::SNPrint(name, 64, ":temp%" Pd, index);
@@ skipping 15 matching lines @@
 }
 
 intptr_t FlowGraphBuilder::CurrentTryIndex() {
   if (try_catch_block_ == NULL) {
     return CatchClauseNode::kInvalidTryIndex;
   } else {
     return try_catch_block_->try_index();
   }
 }
 
-dart::LocalVariable* FlowGraphBuilder::LookupVariable(intptr_t kernel_offset) {
+LocalVariable* FlowGraphBuilder::LookupVariable(intptr_t kernel_offset) {
   LocalVariable* local = scopes_->locals.Lookup(kernel_offset);
   ASSERT(local != NULL);
   return local;
 }
 
 void FlowGraphBuilder::SetTempIndex(Definition* definition) {
   definition->set_temp_index(
       stack_ == NULL ? 0 : stack_->definition()->temp_index() + 1);
 }
 
@@ skipping 25 matching lines @@
   } else {
     definition->ClearTempIndex();
   }
 
   Pop();
   return instructions;
 }
 
 // TODO(27590): This method should be shared with
 // runtime/vm/object.cc:RecognizeArithmeticOp.
-Token::Kind FlowGraphBuilder::MethodKind(const dart::String& name) {
+Token::Kind FlowGraphBuilder::MethodKind(const String& name) {
   ASSERT(name.IsSymbol());
   if (name.raw() == Symbols::Plus().raw()) {
     return Token::kADD;
   } else if (name.raw() == Symbols::Minus().raw()) {
     return Token::kSUB;
   } else if (name.raw() == Symbols::Star().raw()) {
     return Token::kMUL;
   } else if (name.raw() == Symbols::Slash().raw()) {
     return Token::kDIV;
   } else if (name.raw() == Symbols::TruncDivOperator().raw()) {
@@ skipping 19 matching lines @@
   } else if (name.raw() == Symbols::Token(Token::kNE).raw()) {
     return Token::kNE;
   } else if (name.raw() == Symbols::LAngleBracket().raw()) {
     return Token::kLT;
   } else if (name.raw() == Symbols::RAngleBracket().raw()) {
     return Token::kGT;
   } else if (name.raw() == Symbols::LessEqualOperator().raw()) {
     return Token::kLTE;
   } else if (name.raw() == Symbols::GreaterEqualOperator().raw()) {
     return Token::kGTE;
-  } else if (dart::Field::IsGetterName(name)) {
+  } else if (Field::IsGetterName(name)) {
     return Token::kGET;
-  } else if (dart::Field::IsSetterName(name)) {
+  } else if (Field::IsSetterName(name)) {
     return Token::kSET;
   }
   return Token::kILLEGAL;
 }
 
 void FlowGraphBuilder::InlineBailout(const char* reason) {
   bool is_inlining = exit_collector_ != NULL;
   if (is_inlining) {
     parsed_function_->function().set_is_inlinable(false);
     parsed_function_->Bailout("kernel::FlowGraphBuilder", reason);
@@ skipping 30 matching lines @@
       body += StrictCompare(Token::kEQ_STRICT);
       break;
     case MethodRecognizer::kStringBaseLength:
     case MethodRecognizer::kStringBaseIsEmpty:
       // Depending on FLAG_support_externalizable_strings, treat string length
       // loads as mutable so that the class check that precedes them will not be
       // hoisted.  This is unsafe because string externalization can change the
       // class.
       body += LoadLocal(scopes_->this_variable);
       body += LoadNativeField(MethodRecognizer::kStringBaseLength,
-                              dart::String::length_offset(),
+                              String::length_offset(),
                               Type::ZoneHandle(Z, Type::SmiType()), kSmiCid,
                               !FLAG_support_externalizable_strings);
       if (kind == MethodRecognizer::kStringBaseIsEmpty) {
         body += IntConstant(0);
         body += StrictCompare(Token::kEQ_STRICT);
       }
       break;
     case MethodRecognizer::kGrowableArrayLength:
       body += LoadLocal(scopes_->this_variable);
       body += LoadNativeField(kind, GrowableObjectArray::length_offset(),
@@ skipping 100 matching lines @@
                                  LinkedHashMap::deleted_keys_offset(),
                                  kNoStoreBarrier);
       body += NullConstant();
       break;
     case MethodRecognizer::kBigint_getNeg:
       body += LoadLocal(scopes_->this_variable);
       body += LoadNativeField(kind, Bigint::neg_offset(),
                               Type::ZoneHandle(Z, Type::BoolType()), kBoolCid);
       break;
     default: {
-      dart::String& name = dart::String::ZoneHandle(Z, function.native_name());
+      String& name = String::ZoneHandle(Z, function.native_name());
       body += NativeCall(&name, &function);
       break;
     }
   }
   return body + Return(TokenPosition::kNoSource);
 }
 
 Fragment FlowGraphBuilder::BuildImplicitClosureCreation(
     const Function& target) {
   Fragment fragment;
-  const dart::Class& closure_class =
-      dart::Class::ZoneHandle(Z, I->object_store()->closure_class());
+  const Class& closure_class =
+      Class::ZoneHandle(Z, I->object_store()->closure_class());
   fragment += AllocateObject(closure_class, target);
   LocalVariable* closure = MakeTemporary();
 
   // The function signature can have uninstantiated class type parameters.
   //
   // TODO(regis): Also handle the case of a function signature that has
   // uninstantiated function type parameters.
   if (!target.HasInstantiatedSignature(kCurrentClass)) {
     fragment += LoadLocal(closure);
     fragment += LoadInstantiatorTypeArguments();
@@ skipping 20 matching lines @@
   // The context is on top of the operand stack.  Store `this`.  The context
   // doesn't need a parent pointer because it doesn't close over anything
   // else.
   fragment += LoadLocal(scopes_->this_variable);
   fragment +=
       StoreInstanceField(TokenPosition::kNoSource, Context::variable_offset(0));
 
   return fragment;
 }
 
-Fragment FlowGraphBuilder::GuardFieldLength(const dart::Field& field,
+Fragment FlowGraphBuilder::GuardFieldLength(const Field& field,
                                             intptr_t deopt_id) {
   return Fragment(new (Z) GuardFieldLengthInstr(Pop(), field, deopt_id));
 }
 
-Fragment FlowGraphBuilder::GuardFieldClass(const dart::Field& field,
+Fragment FlowGraphBuilder::GuardFieldClass(const Field& field,
                                            intptr_t deopt_id) {
   return Fragment(new (Z) GuardFieldClassInstr(Pop(), field, deopt_id));
 }
 
 Fragment FlowGraphBuilder::CheckVariableTypeInCheckedMode(
     const AbstractType& dst_type,
-    const dart::String& name_symbol) {
+    const String& name_symbol) {
   if (I->type_checks()) {
     if (dst_type.IsMalformed()) {
       return ThrowTypeError();
     }
     return CheckAssignableInCheckedMode(dst_type, name_symbol);
   }
   return Fragment();
 }
 
 bool FlowGraphBuilder::NeedsDebugStepCheck(const Function& function,
@@ skipping 17 matching lines @@
   return definition->IsLoadLocal() &&
          !definition->AsLoadLocal()->local().IsInternal();
 }
 
 Fragment FlowGraphBuilder::DebugStepCheck(TokenPosition position) {
   return Fragment(new (Z) DebugStepCheckInstr(
       position, RawPcDescriptors::kRuntimeCall, GetNextDeoptId()));
 }
 
 Fragment FlowGraphBuilder::EvaluateAssertion() {
-  const dart::Class& klass = dart::Class::ZoneHandle(
-      Z, dart::Library::LookupCoreClass(Symbols::AssertionError()));
+  const Class& klass =
+      Class::ZoneHandle(Z, Library::LookupCoreClass(Symbols::AssertionError()));
   ASSERT(!klass.IsNull());
   const Function& target =
       Function::ZoneHandle(Z, klass.LookupStaticFunctionAllowPrivate(
                                   H.DartSymbol("_evaluateAssertion")));
   ASSERT(!target.IsNull());
   return StaticCall(TokenPosition::kNoSource, target, 1);
 }
 
 Fragment FlowGraphBuilder::CheckReturnTypeInCheckedMode() {
   if (I->type_checks()) {
@@ skipping 10 matching lines @@
     LocalVariable* top_of_stack = MakeTemporary();
     instructions += LoadLocal(top_of_stack);
     instructions += AssertBool();
     instructions += Drop();
   }
   return instructions;
 }
 
 Fragment FlowGraphBuilder::CheckAssignableInCheckedMode(
     const AbstractType& dst_type,
-    const dart::String& dst_name) {
+    const String& dst_name) {
   Fragment instructions;
   if (I->type_checks() && !dst_type.IsDynamicType() &&
       !dst_type.IsObjectType() && !dst_type.IsVoidType()) {
     LocalVariable* top_of_stack = MakeTemporary();
     instructions += LoadLocal(top_of_stack);
     instructions += AssertAssignable(dst_type, dst_name);
     instructions += Drop();
   }
   return instructions;
 }
 
 Fragment FlowGraphBuilder::AssertBool() {
   Value* value = Pop();
   AssertBooleanInstr* instr = new (Z)
       AssertBooleanInstr(TokenPosition::kNoSource, value, GetNextDeoptId());
   Push(instr);
   return Fragment(instr);
 }
 
 Fragment FlowGraphBuilder::AssertAssignable(const AbstractType& dst_type,
-                                            const dart::String& dst_name) {
+                                            const String& dst_name) {
   Fragment instructions;
   Value* value = Pop();
 
   if (!dst_type.IsInstantiated(kCurrentClass)) {
     instructions += LoadInstantiatorTypeArguments();
   } else {
     instructions += NullConstant();
   }
   Value* instantiator_type_args = Pop();
 
@@ skipping 60 matching lines @@
   // TODO(regis): Check if a type argument vector is passed.
 
   // The receiver is the first argument to noSuchMethod, and it is the first
   // argument passed to the dispatcher function.
   LocalScope* scope = parsed_function_->node_sequence()->scope();
   body += LoadLocal(scope->VariableAt(0));
   body += PushArgument();
 
   // The second argument to noSuchMethod is an invocation mirror.  Push the
   // arguments for allocating the invocation mirror.  First, the name.
-  body += Constant(dart::String::ZoneHandle(Z, function.name()));
+  body += Constant(String::ZoneHandle(Z, function.name()));
   body += PushArgument();
 
   // Second, the arguments descriptor.
   body += Constant(descriptor_array);
   body += PushArgument();
 
   // Third, an array containing the original arguments.  Create it and fill
   // it in.
   body += Constant(TypeArguments::ZoneHandle(Z, TypeArguments::null()));
   body += IntConstant(descriptor.Count());
   body += CreateArray();
   LocalVariable* array = MakeTemporary();
   for (intptr_t i = 0; i < descriptor.PositionalCount(); ++i) {
     body += LoadLocal(array);
     body += IntConstant(i);
     body += LoadLocal(scope->VariableAt(i));
     body += StoreIndexed(kArrayCid);
     body += Drop();
   }
-  dart::String& name = dart::String::Handle(Z);
+  String& name = String::Handle(Z);
   for (intptr_t i = 0; i < descriptor.NamedCount(); ++i) {
     intptr_t parameter_index = descriptor.PositionalCount() + i;
     name = descriptor.NameAt(i);
     name = Symbols::New(H.thread(), name);
     body += LoadLocal(array);
     body += IntConstant(descriptor.PositionAt(i));
     body += LoadLocal(scope->VariableAt(parameter_index));
     body += StoreIndexed(kArrayCid);
     body += Drop();
   }
   body += PushArgument();
 
   // Fourth, false indicating this is not a super NoSuchMethod.
   body += Constant(Bool::False());
   body += PushArgument();
 
-  const dart::Class& mirror_class = dart::Class::Handle(
-      Z, dart::Library::LookupCoreClass(Symbols::InvocationMirror()));
+  const Class& mirror_class =
+      Class::Handle(Z, Library::LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
-      Z, mirror_class.LookupStaticFunction(dart::Library::PrivateCoreLibName(
-             Symbols::AllocateInvocationMirror())));
+      Z, mirror_class.LookupStaticFunction(
+             Library::PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
   ASSERT(!allocation_function.IsNull());
   body += StaticCall(TokenPosition::kMinSource, allocation_function, 4);
   body += PushArgument();  // For the call to noSuchMethod.
 
   const int kTypeArgsLen = 0;
   ArgumentsDescriptor two_arguments(
       Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, 2)));
   Function& no_such_method =
       Function::ZoneHandle(Z, Resolver::ResolveDynamicForReceiverClass(
-                                  dart::Class::Handle(Z, function.Owner()),
+                                  Class::Handle(Z, function.Owner()),
                                   Symbols::NoSuchMethod(), two_arguments));
   if (no_such_method.IsNull()) {
     // If noSuchMethod is not found on the receiver class, call
     // Object.noSuchMethod.
     no_such_method = Resolver::ResolveDynamicForReceiverClass(
-        dart::Class::Handle(Z, I->object_store()->object_class()),
+        Class::Handle(Z, I->object_store()->object_class()),
         Symbols::NoSuchMethod(), two_arguments);
   }
   body += StaticCall(TokenPosition::kMinSource, no_such_method, 2);
   body += Return(TokenPosition::kNoSource);
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher(
     const Function& function) {
   // Find the name of the field we should dispatch to.
-  const dart::Class& owner = dart::Class::Handle(Z, function.Owner());
+  const Class& owner = Class::Handle(Z, function.Owner());
   ASSERT(!owner.IsNull());
-  const dart::String& field_name = dart::String::Handle(Z, function.name());
-  const dart::String& getter_name = dart::String::ZoneHandle(
-      Z,
-      Symbols::New(H.thread(), dart::String::Handle(
-                                   Z, dart::Field::GetterSymbol(field_name))));
+  const String& field_name = String::Handle(Z, function.name());
+  const String& getter_name = String::ZoneHandle(
+      Z, Symbols::New(H.thread(),
+                      String::Handle(Z, Field::GetterSymbol(field_name))));
 
   // Determine if this is `class Closure { get call => this; }`
-  const dart::Class& closure_class =
-      dart::Class::Handle(Z, I->object_store()->closure_class());
+  const Class& closure_class =
+      Class::Handle(Z, I->object_store()->closure_class());
   const bool is_closure_call = (owner.raw() == closure_class.raw()) &&
                                field_name.Equals(Symbols::Call());
 
   // Set default parameters & construct argument names array.
   //
   // The backend will expect an array of default values for all the named
   // parameters, even if they are all known to be passed at the call site
   // because the call site matches the arguments descriptor.  Use null for
   // the default values.
   const Array& descriptor_array =
       Array::ZoneHandle(Z, function.saved_args_desc());
   ArgumentsDescriptor descriptor(descriptor_array);
   const Array& argument_names =
       Array::ZoneHandle(Z, Array::New(descriptor.NamedCount(), Heap::kOld));
   ZoneGrowableArray<const Instance*>* default_values =
       new ZoneGrowableArray<const Instance*>(Z, descriptor.NamedCount());
-  dart::String& string_handle = dart::String::Handle(Z);
+  String& string_handle = String::Handle(Z);
   for (intptr_t i = 0; i < descriptor.NamedCount(); ++i) {
     default_values->Add(&Object::null_instance());
     string_handle = descriptor.NameAt(i);
     argument_names.SetAt(i, string_handle);
   }
   parsed_function_->set_default_parameter_values(default_values);
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
@@ skipping 73 matching lines @@
     ASSERT(stack_->definition()->IsPushArgument());
     ASSERT(!stack_->definition()->HasSSATemp());
     arguments->data()[i] = stack_->definition()->AsPushArgument();
     Drop();
   }
   pending_argument_count_ -= count;
   ASSERT(pending_argument_count_ >= 0);
   return arguments;
 }
 
-RawObject* EvaluateMetadata(const dart::Field& metadata_field) {
+RawObject* EvaluateMetadata(const Field& metadata_field) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* thread = Thread::Current();
     Zone* zone_ = thread->zone();
     TranslationHelper helper(thread);
     Script& script = Script::Handle(Z, metadata_field.Script());
     helper.SetStringOffsets(
         TypedData::Handle(Z, script.kernel_string_offsets()));
     helper.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
     helper.SetCanonicalNames(
@@ skipping 121 matching lines @@
       entry = it.GetNext();
       data = TypedData::null();
       if (entry.IsClass()) {
         const Class& klass = Class::Cast(entry);
         entry_script = klass.script();
         if (!entry_script.IsNull() && script.kernel_script_index() ==
                                           entry_script.kernel_script_index()) {
           token_positions.Add(klass.token_pos().value());
         }
         Array& array = Array::Handle(zone_, klass.fields());
-        dart::Field& field = dart::Field::Handle(Z);
+        Field& field = Field::Handle(Z);
         for (intptr_t i = 0; i < array.Length(); ++i) {
           field ^= array.At(i);
           data = field.kernel_data();
           entry_script = field.Script();
           ProcessTokenPositionsEntry(data, script, entry_script,
                                      field.kernel_offset(), zone_, &helper,
                                      &token_positions, &yield_positions);
         }
         array = klass.functions();
         Function& function = Function::Handle(Z);
         for (intptr_t i = 0; i < array.Length(); ++i) {
           function ^= array.At(i);
           data = function.kernel_data();
           entry_script = function.script();
           ProcessTokenPositionsEntry(data, script, entry_script,
                                      function.kernel_offset(), zone_, &helper,
                                      &token_positions, &yield_positions);
         }
       } else if (entry.IsFunction()) {
         const Function& function = Function::Cast(entry);
         data = function.kernel_data();
         entry_script = function.script();
         ProcessTokenPositionsEntry(data, script, entry_script,
                                    function.kernel_offset(), zone_, &helper,
                                    &token_positions, &yield_positions);
       } else if (entry.IsField()) {
-        const dart::Field& field = dart::Field::Cast(entry);
+        const Field& field = Field::Cast(entry);
         data = field.kernel_data();
         entry_script = field.Script();
         ProcessTokenPositionsEntry(data, script, entry_script,
                                    field.kernel_offset(), zone_, &helper,
                                    &token_positions, &yield_positions);
       }
     }
   }
 
   Array& array_object = Array::Handle(Z);
   array_object = AsSortedDuplicateFreeArray(&token_positions);
   script.set_debug_positions(array_object);
   array_object = AsSortedDuplicateFreeArray(&yield_positions);
   script.set_yield_positions(array_object);
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)