Do not qualify with dart:: except where necessary

runtime/vm/kernel_binary_flowgraph.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_binary_flowgraph.h"
 #include "vm/compiler.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
 #define H (translation_helper_)
 #define T (type_translator_)
 #define I Isolate::Current()
 
 static bool IsStaticInitializer(const Function& function, Zone* zone) {
   return (function.kind() == RawFunction::kImplicitStaticFinalGetter) &&
-         dart::String::Handle(zone, function.name())
+         String::Handle(zone, function.name())
              .StartsWith(Symbols::InitPrefix());
 }
 
 void FunctionNodeHelper::ReadUntilExcluding(Field field) {
   if (field <= next_read_) return;
 
   // Ordered with fall-through.
   switch (next_read_) {
     case kStart: {
       Tag tag = builder_->ReadTag();  // read tag.
@@ skipping 478 matching lines @@
 ScopeBuildingResult* StreamingScopeBuilder::BuildScopes() {
   if (result_ != NULL) return result_;
 
   ASSERT(scope_ == NULL && depth_.loop_ == 0 && depth_.function_ == 0);
   result_ = new (Z) ScopeBuildingResult();
 
   const 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());
+  const Class& klass =
+      Class::Handle(zone_, parsed_function_->function().Owner());
 
   Function& outermost_function = Function::Handle(Z);
   builder_->DiscoverEnclosingElements(Z, function, &outermost_function);
 
   ActiveClassScope active_class_scope(&active_class_, &klass);
   ActiveMemberScope active_member(&active_class_, &outermost_function);
 
   LocalScope* enclosing_scope = NULL;
   if (function.IsLocalFunction()) {
     enclosing_scope = LocalScope::RestoreOuterScope(
@@ skipping 41 matching lines @@
       intptr_t pos = 0;
       if (function.IsClosureFunction()) {
         LocalVariable* variable = MakeVariable(
             TokenPosition::kNoSource, TokenPosition::kNoSource,
             Symbols::ClosureParameter(), AbstractType::dynamic_type());
         variable->set_is_forced_stack();
         scope_->InsertParameterAt(pos++, variable);
       } else if (!function.is_static()) {
         // We use [is_static] instead of [IsStaticFunction] because the latter
         // returns `false` for constructors.
-        dart::Class& klass = dart::Class::Handle(Z, function.Owner());
+        Class& klass = Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable =
             MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                          Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
 
         // We visit instance field initializers because they might contain
         // [Let] expressions and we need to have a mapping.
         if (tag == kConstructor) {
           Class& parent_class = Class::Handle(Z, function.Owner());
           Array& class_fields = Array::Handle(Z, parent_class.fields());
-          dart::Field& class_field = dart::Field::Handle(Z);
+          Field& class_field = Field::Handle(Z);
           for (intptr_t i = 0; i < class_fields.Length(); ++i) {
             class_field ^= class_fields.At(i);
             if (!class_field.is_static()) {
               TypedData& kernel_data =
                   TypedData::Handle(Z, class_field.kernel_data());
               ASSERT(!kernel_data.IsNull());
               AlternativeReadingScope alt(builder_->reader_, &kernel_data, 0);
               intptr_t saved_relative_kernel_offset_ = relative_kernel_offset_;
               relative_kernel_offset_ = class_field.kernel_offset();
               FieldHelper field_helper(builder_);
@@ skipping 51 matching lines @@
     case RawFunction::kImplicitSetter: {
       ASSERT(builder_->PeekTag() == kField);
       if (IsStaticInitializer(function, Z)) {
         VisitNode();
         break;
       }
       bool is_setter = function.IsImplicitSetterFunction();
       bool is_method = !function.IsStaticFunction();
       intptr_t pos = 0;
       if (is_method) {
-        dart::Class& klass = dart::Class::Handle(Z, function.Owner());
+        Class& klass = Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable =
             MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                          Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
       }
       if (is_setter) {
         result_->setter_value =
             MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                          Symbols::Value(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, result_->setter_value);
       }
       break;
     }
     case RawFunction::kMethodExtractor: {
       // Add a receiver parameter.  Though it is captured, we emit code to
       // explicitly copy it to a fixed offset in a freshly-allocated context
       // instead of using the generic code for regular functions.
       // Therefore, it isn't necessary to mark it as captured here.
-      dart::Class& klass = dart::Class::Handle(Z, function.Owner());
+      Class& klass = Class::Handle(Z, function.Owner());
       Type& klass_type = H.GetCanonicalType(klass);
       LocalVariable* variable =
           MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                        Symbols::This(), klass_type);
       scope_->InsertParameterAt(0, variable);
       result_->this_variable = variable;
       break;
     }
     case RawFunction::kNoSuchMethodDispatcher:
     case RawFunction::kInvokeFieldDispatcher:
       for (intptr_t i = 0; i < function.NumParameters(); ++i) {
-        LocalVariable* variable = MakeVariable(
-            TokenPosition::kNoSource, TokenPosition::kNoSource,
-            dart::String::ZoneHandle(Z, function.ParameterNameAt(i)),
-            AbstractType::dynamic_type());
+        LocalVariable* variable =
+            MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                         String::ZoneHandle(Z, function.ParameterNameAt(i)),
+                         AbstractType::dynamic_type());
         scope_->InsertParameterAt(i, variable);
       }
       break;
     case RawFunction::kSignatureFunction:
     case RawFunction::kIrregexpFunction:
       UNREACHABLE();
   }
   if (needs_expr_temp_) {
     scope_->AddVariable(parsed_function_->EnsureExpressionTemp());
   }
@@ skipping 28 matching lines @@
   // compiled as if they appear in the constructor initializer list.  This is
   // important for closure-valued field initializers because the VM expects the
   // corresponding closure functions to appear as if they were nested inside the
   // constructor.
   ConstructorHelper constructor_helper(builder_);
   constructor_helper.ReadUntilExcluding(ConstructorHelper::kFunction);
   {
     const Function& function = parsed_function_->function();
     Class& parent_class = Class::Handle(Z, function.Owner());
     Array& class_fields = Array::Handle(Z, parent_class.fields());
-    dart::Field& class_field = dart::Field::Handle(Z);
+    Field& class_field = Field::Handle(Z);
     for (intptr_t i = 0; i < class_fields.Length(); ++i) {
       class_field ^= class_fields.At(i);
       if (!class_field.is_static()) {
         TypedData& kernel_data =
             TypedData::Handle(Z, class_field.kernel_data());
         ASSERT(!kernel_data.IsNull());
         AlternativeReadingScope alt(builder_->reader_, &kernel_data, 0);
         intptr_t saved_relative_kernel_offset_ = relative_kernel_offset_;
         relative_kernel_offset_ = class_field.kernel_offset();
         FieldHelper field_helper(builder_);
@@ skipping 534 matching lines @@
       builder_->ReadUInt();  // read target_index.
       return;
     case kIfStatement:
       VisitExpression();  // read condition.
       VisitStatement();   // read then.
       VisitStatement();   // read otherwise.
       return;
     case kReturnStatement: {
       if ((depth_.function_ == 0) && (depth_.finally_ > 0) &&
           (result_->finally_return_variable == NULL)) {
-        const dart::String& name = H.DartSymbol(":try_finally_return_value");
+        const String& name = H.DartSymbol(":try_finally_return_value");
         LocalVariable* variable =
             MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                          name, AbstractType::dynamic_type());
         current_function_scope_->AddVariable(variable);
         result_->finally_return_variable = variable;
       }
 
       builder_->ReadPosition();       // read position
       Tag tag = builder_->ReadTag();  // read (first part of) expression.
       if (tag == kSomething) {
@@ skipping 114 matching lines @@
 
   intptr_t kernel_offset_no_tag = builder_->ReaderOffset();
   VariableDeclarationHelper helper(builder_);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kType);
   intptr_t offset_for_type = builder_->ReaderOffset();
   AbstractType& type = T.BuildVariableType();  // read type.
 
   // In case `declaration->IsConst()` the flow graph building will take care of
   // evaluating the constant and setting it via
   // `declaration->SetConstantValue()`.
-  const dart::String& name = (H.StringSize(helper.name_index_) == 0)
-                                 ? GenerateName(":var", name_index_++)
-                                 : H.DartSymbol(helper.name_index_);
+  const String& name = (H.StringSize(helper.name_index_) == 0)
+                           ? GenerateName(":var", name_index_++)
+                           : H.DartSymbol(helper.name_index_);
   // We also need to visit the type.
   builder_->SetOffset(offset_for_type);
   VisitDartType();  // read type.
 
   Tag tag = builder_->ReadTag();  // read (first part of) initializer.
   if (tag == kSomething) {
     VisitExpression();  // read (actual) initializer.
   }
 
   // Go to next token position so it ends *after* the last potentially
@@ skipping 201 matching lines @@
   // evaluator needs scope bindings.
   Tag tag = builder_->ReadTag();
   if (tag == kSomething) {
     VisitExpression();  // read initializer.
   }
 }
 
 LocalVariable* StreamingScopeBuilder::MakeVariable(
     TokenPosition declaration_pos,
     TokenPosition token_pos,
-    const dart::String& name,
+    const String& name,
     const AbstractType& type) {
   return new (Z) LocalVariable(declaration_pos, token_pos, name, type);
 }
 
 void StreamingScopeBuilder::AddExceptionVariable(
     GrowableArray<LocalVariable*>* variables,
     const char* prefix,
     intptr_t nesting_depth) {
   LocalVariable* v = NULL;
 
@@ skipping 75 matching lines @@
   LocalVariable* variable = result_->locals.Lookup(declaration_binary_offset);
   if (variable == NULL) {
     // We have not seen a declaration of the variable, so it must be the
     // case that we are compiling a nested function and the variable is
     // declared in an outer scope.  In that case, look it up in the scope by
     // name and add it to the variable map to simplify later lookup.
     ASSERT(current_function_scope_->parent() != NULL);
     StringIndex var_name = builder_->GetNameFromVariableDeclaration(
         declaration_binary_offset, parsed_function_->function());
 
-    const dart::String& name = H.DartSymbol(var_name);
+    const String& name = H.DartSymbol(var_name);
     variable = current_function_scope_->parent()->LookupVariable(name, true);
     ASSERT(variable != NULL);
     result_->locals.Insert(declaration_binary_offset, variable);
   }
 
   if (variable->owner()->function_level() < scope_->function_level()) {
     // We call `LocalScope->CaptureVariable(variable)` in two scenarios for two
     // different reasons:
     //   Scenario 1:
     //       We need to know which variables defined in this function
     //       are closed over by nested closures in order to ensure we will
     //       create a [Context] object of appropriate size and store captured
     //       variables there instead of the stack.
     //   Scenario 2:
     //       We need to find out which variables defined in enclosing functions
     //       are closed over by this function/closure or nested closures. This
     //       is necessary in order to build a fat flattened [ContextScope]
     //       object.
     scope_->CaptureVariable(variable);
   } else {
     ASSERT(variable->owner()->function_level() == scope_->function_level());
   }
 }
 
-const dart::String& StreamingScopeBuilder::GenerateName(const char* prefix,
-                                                        intptr_t suffix) {
+const String& StreamingScopeBuilder::GenerateName(const char* prefix,
+                                                  intptr_t suffix) {
   char name[64];
   OS::SNPrint(name, 64, "%s%" Pd "", prefix, suffix);
   return H.DartSymbol(name);
 }
 
 void StreamingScopeBuilder::HandleSpecialLoad(LocalVariable** variable,
-                                              const dart::String& symbol) {
+                                              const String& symbol) {
   if (current_function_scope_->parent() != NULL) {
     // We are building the scope tree of a closure function and saw [node]. We
     // lazily populate the variable using the parent function scope.
     if (*variable == NULL) {
       *variable =
           current_function_scope_->parent()->LookupVariable(symbol, true);
       ASSERT(*variable != NULL);
     }
   }
 
   if ((current_function_scope_->parent() != NULL) ||
       (scope_->function_level() > 0)) {
     // Every scope we use the [variable] from needs to be notified of the usage
     // in order to ensure that preserving the context scope on that particular
     // use-site also includes the [variable].
     scope_->CaptureVariable(*variable);
   }
 }
 
 void StreamingScopeBuilder::LookupCapturedVariableByName(
     LocalVariable** variable,
-    const dart::String& name) {
+    const String& name) {
   if (*variable == NULL) {
     *variable = scope_->LookupVariable(name, true);
     ASSERT(*variable != NULL);
     scope_->CaptureVariable(*variable);
   }
 }
 
 StreamingDartTypeTranslator::StreamingDartTypeTranslator(
     StreamingFlowGraphBuilder* builder,
     bool finalize)
     : builder_(builder),
       translation_helper_(builder->translation_helper_),
       active_class_(builder->active_class()),
       type_parameter_scope_(NULL),
       zone_(translation_helper_.zone()),
       result_(AbstractType::Handle(translation_helper_.zone())),
       finalize_(finalize) {}
 
 AbstractType& StreamingDartTypeTranslator::BuildType() {
   BuildTypeInternal();
 
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
-  return dart::AbstractType::ZoneHandle(Z, result_.raw());
+  return AbstractType::ZoneHandle(Z, result_.raw());
 }
 
 AbstractType& StreamingDartTypeTranslator::BuildTypeWithoutFinalization() {
   bool saved_finalize = finalize_;
   finalize_ = false;
   BuildTypeInternal();
   finalize_ = saved_finalize;
 
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
-  return dart::AbstractType::ZoneHandle(Z, result_.raw());
+  return AbstractType::ZoneHandle(Z, result_.raw());
 }
 
 AbstractType& StreamingDartTypeTranslator::BuildVariableType() {
   AbstractType& abstract_type = BuildType();
 
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
   AbstractType& type = Type::ZoneHandle(Z);
 
   if (abstract_type.IsMalformed()) {
     type = AbstractType::dynamic_type().raw();
   } else {
     type = result_.raw();
   }
 
   return type;
 }
 
 void StreamingDartTypeTranslator::BuildTypeInternal() {
   Tag tag = builder_->ReadTag();
   switch (tag) {
     case kInvalidType:
       result_ = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(Z),  // No previous error.
-          dart::Script::Handle(Z, dart::Script::null()),
-          TokenPosition::kNoSource, "[InvalidType] in Kernel IR.");
+          Script::Handle(Z, Script::null()), TokenPosition::kNoSource,
+          "[InvalidType] in Kernel IR.");
       break;
     case kDynamicType:
       result_ = Object::dynamic_type().raw();
       break;
     case kVoidType:
       result_ = Object::void_type().raw();
       break;
     case kVectorType:
       result_ = Object::vector_type().raw();
       break;
     case kBottomType:
-      result_ = dart::Class::Handle(Z, I->object_store()->null_class())
-                    .CanonicalType();
+      result_ =
+          Class::Handle(Z, I->object_store()->null_class()).CanonicalType();
       break;
     case kInterfaceType:
       BuildInterfaceType(false);
       break;
     case kSimpleInterfaceType:
       BuildInterfaceType(true);
       break;
     case kFunctionType:
       BuildFunctionType(false);
       break;
@@ skipping 18 matching lines @@
 
   intptr_t length;
   if (simple) {
     length = 0;
   } else {
     length = builder_->ReadListLength();  // read type_arguments list length.
   }
   const TypeArguments& type_arguments =
       BuildTypeArguments(length);  // read type arguments.
 
-  dart::Object& klass =
-      dart::Object::Handle(Z, H.LookupClassByKernelClass(klass_name));
+  Object& klass = Object::Handle(Z, H.LookupClassByKernelClass(klass_name));
   result_ = Type::New(klass, type_arguments, TokenPosition::kNoSource);
   if (finalize_) {
     ASSERT(active_class_->klass != NULL);
     result_ = ClassFinalizer::FinalizeType(*active_class_->klass, result_);
   }
 }
 
 void StreamingDartTypeTranslator::BuildFunctionType(bool simple) {
   intptr_t list_length = 0;
   if (!simple) {
@@ skipping 57 matching lines @@
   // The additional first parameter is the receiver type (set to dynamic).
   signature_function.set_num_fixed_parameters(1 + required_count);
   signature_function.SetNumOptionalParameters(
       all_count - required_count, positional_count > required_count);
 
   if (!simple) {
     const intptr_t named_count =
         builder_->ReadListLength();  // read named_parameters list length.
     for (intptr_t i = 0; i < named_count; ++i, ++pos) {
       // read string reference (i.e. named_parameters[i].name).
-      dart::String& name = H.DartSymbol(builder_->ReadStringReference());
+      String& name = H.DartSymbol(builder_->ReadStringReference());
       BuildTypeInternal();  // read named_parameters[i].type.
       if (result_.IsMalformed()) {
         result_ = AbstractType::dynamic_type().raw();
       }
       parameter_types.SetAt(pos, result_);
       parameter_names.SetAt(pos, name);
     }
   }
 
   builder_->SkipListOfStrings();  // read positional parameter names.
@@ skipping 20 matching lines @@
   }
 
   result_ = signature_type.raw();
 }
 
 void StreamingDartTypeTranslator::BuildTypeParameterType() {
   intptr_t parameter_index = builder_->ReadUInt();  // read parameter index.
   builder_->SkipOptionalDartType();                 // read bound.
 
   const TypeArguments& class_types =
-      dart::TypeArguments::Handle(Z, active_class_->klass->type_parameters());
+      TypeArguments::Handle(Z, active_class_->klass->type_parameters());
   if (parameter_index < class_types.Length()) {
     // The index of the type parameter in [parameters] is
     // the same index into the `klass->type_parameters()` array.
     result_ ^= class_types.TypeAt(parameter_index);
     return;
   }
   parameter_index -= class_types.Length();
 
   if (active_class_->HasMember()) {
     if (active_class_->MemberIsFactoryProcedure()) {
@@ skipping 22 matching lines @@
       parameter_index -= class_types.Length();
     }
 
     intptr_t procedure_type_parameter_count =
         active_class_->MemberIsProcedure()
             ? active_class_->MemberTypeParameterCount(Z)
             : 0;
     if (procedure_type_parameter_count > 0) {
       if (procedure_type_parameter_count > parameter_index) {
         if (FLAG_reify_generic_functions) {
-          result_ ^= dart::TypeArguments::Handle(
-                         Z, active_class_->member->type_parameters())
-                         .TypeAt(parameter_index);
+          result_ ^=
+              TypeArguments::Handle(Z, active_class_->member->type_parameters())
+                  .TypeAt(parameter_index);
         } else {
-          result_ ^= dart::Type::DynamicType();
+          result_ ^= Type::DynamicType();
         }
         return;
       }
       parameter_index -= procedure_type_parameter_count;
     }
   }
 
   if (type_parameter_scope_ != NULL && parameter_index >= 0 &&
       parameter_index < type_parameter_scope_->outer_parameter_count() +
                             type_parameter_scope_->parameter_count()) {
-    result_ ^= dart::Type::DynamicType();
+    result_ ^= Type::DynamicType();
     return;
   }
 
   H.ReportError("Unexpected input. Please report this at dartbug.com.");
 }
 
 const TypeArguments& StreamingDartTypeTranslator::BuildTypeArguments(
     intptr_t length) {
   bool only_dynamic = true;
   intptr_t offset = builder_->ReaderOffset();
@@ skipping 22 matching lines @@
 
     if (finalize_) {
       type_arguments = type_arguments.Canonicalize();
     }
   }
   return type_arguments;
 }
 
 const TypeArguments&
 StreamingDartTypeTranslator::BuildInstantiatedTypeArguments(
-    const dart::Class& receiver_class,
+    const Class& receiver_class,
     intptr_t length) {
   const TypeArguments& type_arguments = BuildTypeArguments(length);
 
   // If type_arguments is null all arguments are dynamic.
   // If, however, this class doesn't specify all the type arguments directly we
   // still need to finalize the type below in order to get any non-dynamic types
   // from any super. See http://www.dartbug.com/29537.
   if (type_arguments.IsNull() && receiver_class.NumTypeArguments() == length) {
     return type_arguments;
   }
 
   // We make a temporary [Type] object and use `ClassFinalizer::FinalizeType` to
   // finalize the argument types.
   // (This can for example make the [type_arguments] vector larger)
   Type& type = Type::Handle(
       Z, Type::New(receiver_class, type_arguments, TokenPosition::kNoSource));
   if (finalize_) {
     type ^= ClassFinalizer::FinalizeType(*active_class_->klass, type);
   }
 
   const TypeArguments& instantiated_type_arguments =
       TypeArguments::ZoneHandle(Z, type.arguments());
   return instantiated_type_arguments;
 }
 
-const Type& StreamingDartTypeTranslator::ReceiverType(
-    const dart::Class& klass) {
+const Type& StreamingDartTypeTranslator::ReceiverType(const Class& klass) {
   ASSERT(!klass.IsNull());
   ASSERT(!klass.IsTypedefClass());
   // Note that if klass 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());
@@ skipping 212 matching lines @@
   builder_->ReadPosition();  // read position.
   intptr_t expression_offset = builder_->ReaderOffset();
   builder_->SkipExpression();                            // read receiver.
   StringIndex name = builder_->ReadNameAsStringIndex();  // read name.
   // Read unused "interface_target_reference".
   builder_->SkipCanonicalNameReference();
 
   if (H.StringEquals(name, "length")) {
     EvaluateExpression(expression_offset);
     if (result_.IsString()) {
-      const dart::String& str =
-          dart::String::Handle(Z, dart::String::RawCast(result_.raw()));
+      const String& str = String::Handle(Z, String::RawCast(result_.raw()));
       result_ = Integer::New(str.Length());
     } else {
       H.ReportError(
           "Constant expressions can only call "
           "'length' on string constants.");
     }
   } else {
     UNREACHABLE();
   }
 }
 
 void StreamingConstantEvaluator::EvaluateStaticGet() {
   builder_->ReadPosition();  // read position.
   NameIndex target =
       builder_->ReadCanonicalNameReference();  // read target_reference.
 
   if (H.IsField(target)) {
-    const dart::Field& field =
-        dart::Field::Handle(Z, H.LookupFieldByKernelField(target));
+    const Field& field = 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 (H.IsProcedure(target)) {
     const Function& function =
         Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
 
     if (H.IsMethod(target)) {
       Function& closure_function =
           Function::ZoneHandle(Z, function.ImplicitClosureFunction());
       result_ = closure_function.ImplicitStaticClosure();
       result_ = H.Canonicalize(result_);
     } else if (H.IsGetter(target)) {
       UNIMPLEMENTED();
     } else {
       UNIMPLEMENTED();
     }
   }
 }
 
 void StreamingConstantEvaluator::EvaluateMethodInvocation() {
   builder_->ReadPosition();  // read position.
   // This method call wasn't cached, so receiver et al. isn't cached either.
-  const dart::Instance& receiver =
+  const Instance& receiver =
       EvaluateExpression(builder_->ReaderOffset(), false);  // read receiver.
-  dart::Class& klass = dart::Class::Handle(
-      Z, isolate_->class_table()->At(receiver.GetClassId()));
+  Class& klass =
+      Class::Handle(Z, isolate_->class_table()->At(receiver.GetClassId()));
   ASSERT(!klass.IsNull());
 
   // Search the superclass chain for the selector.
-  dart::Function& function = dart::Function::Handle(Z);
-  const dart::String& method_name =
-      builder_->ReadNameAsMethodName();  // read name.
+  Function& function = Function::Handle(Z);
+  const String& method_name = builder_->ReadNameAsMethodName();  // read name.
   while (!klass.IsNull()) {
     function = klass.LookupDynamicFunctionAllowPrivate(method_name);
     if (!function.IsNull()) break;
     klass = klass.SuperClass();
   }
 
   // The frontend should guarantee that [MethodInvocation]s inside constant
   // expressions are always valid.
   ASSERT(!function.IsNull());
 
@@ skipping 11 matching lines @@
   builder_->SkipCanonicalNameReference();  // read "interface_target_reference"
 }
 
 void StreamingConstantEvaluator::EvaluateStaticInvocation() {
   builder_->ReadPosition();  // read position.
   NameIndex procedue_reference =
       builder_->ReadCanonicalNameReference();  // read procedure reference.
 
   const Function& function = Function::ZoneHandle(
       Z, H.LookupStaticMethodByKernelProcedure(procedue_reference));
-  dart::Class& klass = dart::Class::Handle(Z, function.Owner());
+  Class& klass = Class::Handle(Z, function.Owner());
 
   intptr_t argument_count =
       builder_->ReadUInt();  // read arguments part #1: arguments count.
 
   // Build the type arguments vector (if necessary).
   const TypeArguments* type_arguments =
       TranslateTypeArguments(function, &klass);  // read argument types.
 
   // read positional and named parameters.
   const Object& result =
       RunFunction(function, argument_count, NULL, type_arguments);
   result_ ^= result.raw();
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateConstructorInvocationInternal() {
   builder_->ReadPosition();  // read position.
 
   NameIndex target = builder_->ReadCanonicalNameReference();  // read target.
   const Function& constructor =
       Function::Handle(Z, H.LookupConstructorByKernelConstructor(target));
-  dart::Class& klass = dart::Class::Handle(Z, constructor.Owner());
+  Class& klass = Class::Handle(Z, constructor.Owner());
 
   intptr_t argument_count =
       builder_->ReadUInt();  // read arguments part #1: arguments count.
 
   // Build the type arguments vector (if necessary).
   const TypeArguments* type_arguments =
       TranslateTypeArguments(constructor, &klass);  // read argument types.
 
   // Prepare either the instance or the type argument vector for the constructor
   // call.
@@ skipping 63 matching lines @@
 
   bool all_string = true;
   const Array& strings = Array::Handle(Z, Array::New(length));
   for (intptr_t i = 0; i < length; ++i) {
     EvaluateExpression(builder_->ReaderOffset(),
                        false);  // read ith expression.
     strings.SetAt(i, result_);
     all_string = all_string && result_.IsString();
   }
   if (all_string) {
-    result_ = dart::String::ConcatAll(strings, Heap::kOld);
+    result_ = String::ConcatAll(strings, Heap::kOld);
     result_ = H.Canonicalize(result_);
   } else {
     // Get string interpolation function.
-    const dart::Class& cls = dart::Class::Handle(
-        Z, dart::Library::LookupCoreClass(Symbols::StringBase()));
+    const Class& cls =
+        Class::Handle(Z, Library::LookupCoreClass(Symbols::StringBase()));
     ASSERT(!cls.IsNull());
     const Function& func = Function::Handle(
         Z, cls.LookupStaticFunction(
-               dart::Library::PrivateCoreLibName(Symbols::Interpolate())));
+               Library::PrivateCoreLibName(Symbols::Interpolate())));
     ASSERT(!func.IsNull());
 
     // Build argument array to pass to the interpolation function.
     const Array& interpolate_arg = Array::Handle(Z, Array::New(1, Heap::kOld));
     interpolate_arg.SetAt(0, strings);
 
     // Run and canonicalize.
     const Object& result =
         RunFunction(func, interpolate_arg, Array::null_array());
-    result_ = H.Canonicalize(dart::String::Cast(result));
+    result_ = H.Canonicalize(String::Cast(result));
   }
 }
 
 void StreamingConstantEvaluator::EvaluateSymbolLiteral() {
-  const dart::String& symbol_value = H.DartSymbol(
+  const String& symbol_value = H.DartSymbol(
       builder_->ReadStringReference());  // read index into string table.
 
-  const dart::Class& symbol_class =
-      dart::Class::ZoneHandle(Z, I->object_store()->symbol_class());
+  const Class& symbol_class =
+      Class::ZoneHandle(Z, I->object_store()->symbol_class());
   ASSERT(!symbol_class.IsNull());
-  const dart::Function& symbol_constructor = Function::ZoneHandle(
+  const Function& symbol_constructor = Function::ZoneHandle(
       Z, symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!symbol_constructor.IsNull());
   result_ ^= EvaluateConstConstructorCall(
       symbol_class, TypeArguments::Handle(Z), symbol_constructor, symbol_value);
 }
 
 void StreamingConstantEvaluator::EvaluateTypeLiteral() {
   const AbstractType& type = T.BuildType();
   if (type.IsMalformed()) {
     H.ReportError("Malformed type literal in constant expression.");
@@ skipping 30 matching lines @@
   for (intptr_t i = 0; i < length; ++i) {
     const_kv_array.SetAt(2 * i + 0, EvaluateExpression(builder_->ReaderOffset(),
                                                        false));  // read key.
     const_kv_array.SetAt(2 * i + 1, EvaluateExpression(builder_->ReaderOffset(),
                                                        false));  // read value.
   }
 
   const_kv_array.MakeImmutable();
   const_kv_array ^= H.Canonicalize(const_kv_array);
 
-  const dart::Class& map_class = dart::Class::Handle(
-      Z, dart::Library::LookupCoreClass(Symbols::ImmutableMap()));
+  const Class& map_class =
+      Class::Handle(Z, Library::LookupCoreClass(Symbols::ImmutableMap()));
   ASSERT(!map_class.IsNull());
   ASSERT(map_class.NumTypeArguments() == 2);
 
-  const dart::Field& field = dart::Field::Handle(
+  const Field& field = Field::Handle(
       Z, map_class.LookupInstanceFieldAllowPrivate(H.DartSymbol("_kvPairs")));
   ASSERT(!field.IsNull());
 
   // NOTE: This needs to be kept in sync with `runtime/lib/immutable_map.dart`!
   result_ = Instance::New(map_class, Heap::kOld);
   ASSERT(!result_.IsNull());
   result_.SetTypeArguments(type_arguments);
   result_.SetField(field, const_kv_array);
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateLet() {
   intptr_t kernel_position =
       builder_->ReaderOffset() + builder_->relative_kernel_offset_;
   LocalVariable* local = builder_->LookupVariable(kernel_position);
 
   // read variable declaration.
   VariableDeclarationHelper helper(builder_);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kInitializer);
   Tag tag = builder_->ReadTag();  // read (first part of) initializer.
   if (tag == kNothing) {
-    local->SetConstValue(Instance::ZoneHandle(Z, dart::Instance::null()));
+    local->SetConstValue(Instance::ZoneHandle(Z, Instance::null()));
   } else {
     local->SetConstValue(EvaluateExpression(
         builder_->ReaderOffset(), false));  // read rest of initializer.
   }
 
   EvaluateExpression(builder_->ReaderOffset(), false);  // read body
 }
 
 void StreamingConstantEvaluator::EvaluateBigIntLiteral() {
-  const dart::String& value =
+  const String& value =
       H.DartString(builder_->ReadStringReference());  // read string reference.
   result_ = Integer::New(value, Heap::kOld);
   if (result_.IsNull()) {
     H.ReportError("Integer literal %s is out of range", value.ToCString());
     UNREACHABLE();
   }
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateStringLiteral() {
   result_ = H.DartSymbol(builder_->ReadStringReference())
                 .raw();  // read string reference.
 }
 
 void StreamingConstantEvaluator::EvaluateIntLiteral(uint8_t payload) {
   int64_t value = static_cast<int32_t>(payload) - SpecializedIntLiteralBias;
-  result_ = dart::Integer::New(value, Heap::kOld);
+  result_ = Integer::New(value, Heap::kOld);
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateIntLiteral(bool is_negative) {
   int64_t value = is_negative ? -static_cast<int64_t>(builder_->ReadUInt())
                               : builder_->ReadUInt();  // read value.
-  result_ = dart::Integer::New(value, Heap::kOld);
+  result_ = Integer::New(value, Heap::kOld);
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateDoubleLiteral() {
   result_ = Double::New(H.DartString(builder_->ReadStringReference()),
                         Heap::kOld);  // read string reference.
   result_ = H.Canonicalize(result_);
 }
 
 void StreamingConstantEvaluator::EvaluateBoolLiteral(bool value) {
-  result_ = dart::Bool::Get(value).raw();
+  result_ = Bool::Get(value).raw();
 }
 
 void StreamingConstantEvaluator::EvaluateNullLiteral() {
-  result_ = dart::Instance::null();
+  result_ = Instance::null();
 }
 
 // This depends on being about to read the list of positionals on arguments.
 const Object& StreamingConstantEvaluator::RunFunction(
     const Function& function,
     intptr_t argument_count,
     const Instance* receiver,
     const TypeArguments* type_args) {
   // We do not support generic methods yet.
   ASSERT((receiver == NULL) || (type_args == NULL));
@@ skipping 16 matching lines @@
   for (intptr_t i = 0; i < list_length; ++i) {
     EvaluateExpression(builder_->ReaderOffset(),
                        false);  // read ith expression.
     arguments.SetAt(pos++, result_);
   }
 
   // List of named.
   list_length = builder_->ReadListLength();  // read list length.
   const Array& names = Array::ZoneHandle(Z, Array::New(list_length));
   for (intptr_t i = 0; i < list_length; ++i) {
-    dart::String& name =
+    String& name =
         H.DartSymbol(builder_->ReadStringReference());  // read ith name index.
     names.SetAt(i, name);
     EvaluateExpression(builder_->ReaderOffset(),
                        false);  // read ith expression.
     arguments.SetAt(pos++, result_);
   }
 
   return RunFunction(function, arguments, names);
 }
 
 const Object& StreamingConstantEvaluator::RunFunction(const Function& function,
                                                       const Array& arguments,
                                                       const Array& names) {
   // We do not support generic methods yet.
   const int kTypeArgsLen = 0;
   const Array& args_descriptor = Array::Handle(
       Z, ArgumentsDescriptor::New(kTypeArgsLen, arguments.Length(), names));
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(function, arguments, args_descriptor));
   if (result.IsError()) {
     H.ReportError(Error::Cast(result), "error evaluating constant constructor");
   }
   return result;
 }
 
 RawObject* StreamingConstantEvaluator::EvaluateConstConstructorCall(
-    const dart::Class& type_class,
+    const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     const Object& argument) {
   // Factories have one extra argument: the type arguments.
   // Constructors have 1 extra arguments: receiver.
   const int kTypeArgsLen = 0;
   const int kNumArgs = 1;
   const int kNumExtraArgs = 1;
   const int argument_count = kNumArgs + kNumExtraArgs;
   const Array& arg_values =
@@ skipping 21 matching lines @@
   ASSERT(!result.IsError());
   if (constructor.IsFactory()) {
     // The factory method returns the allocated object.
     instance ^= result.raw();
   }
   return H.Canonicalize(instance);
 }
 
 const TypeArguments* StreamingConstantEvaluator::TranslateTypeArguments(
     const Function& target,
-    dart::Class* target_klass) {
+    Class* target_klass) {
   intptr_t type_count = builder_->ReadListLength();  // read type count.
 
   const TypeArguments* type_arguments = NULL;
   if (type_count > 0) {
     type_arguments = &T.BuildInstantiatedTypeArguments(
         *target_klass, type_count);  // read types.
 
     if (!(type_arguments->IsNull() || type_arguments->IsInstantiated())) {
       H.ReportError("Type must be constant in const constructor.");
     }
@@ skipping 158 matching lines @@
 
 FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFieldAccessor(
     LocalVariable* setter_value) {
   FieldHelper field_helper(this);
   field_helper.ReadUntilIncluding(FieldHelper::kCanonicalName);
 
   const Function& function = parsed_function()->function();
 
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
-  dart::Field& field = dart::Field::ZoneHandle(
+  Field& field = Field::ZoneHandle(
       Z, H.LookupFieldByKernelField(field_helper.canonical_name_));
 
   TargetEntryInstr* normal_entry = flow_graph_builder_->BuildTargetEntry();
   flow_graph_builder_->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);
@@ skipping 108 matching lines @@
       // List of named.
       list_length = ReadListLength();  // read list length.
       ASSERT(list_length == 0);
     }
     parsed_function()->set_default_parameter_values(default_values);
   }
 }
 
 Fragment StreamingFlowGraphBuilder::BuildFieldInitializer(
     NameIndex canonical_name) {
-  dart::Field& field =
-      dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(canonical_name));
+  Field& field =
+      Field::ZoneHandle(Z, H.LookupFieldByKernelField(canonical_name));
   if (PeekTag() == kNullLiteral) {
     SkipExpression();  // read past the null literal.
     field.RecordStore(Object::null_object());
     return Fragment();
   }
 
   Fragment instructions;
   instructions += LoadLocal(scopes()->this_variable);
   instructions += BuildExpression();
   instructions += flow_graph_builder_->StoreInstanceFieldGuarded(field, true);
@@ skipping 29 matching lines @@
       } else if (PeekTag() == kFieldInitializer) {
         no_field_initializers = false;
       }
       SkipInitializer();
     }
     ASSERT(is_redirecting_constructor ? no_field_initializers : true);
   }
 
   if (!is_redirecting_constructor) {
     Array& class_fields = Array::Handle(Z, parent_class.fields());
-    dart::Field& class_field = dart::Field::Handle(Z);
+    Field& class_field = Field::Handle(Z);
     for (intptr_t i = 0; i < class_fields.Length(); ++i) {
       class_field ^= class_fields.At(i);
       if (!class_field.is_static()) {
         TypedData& kernel_data =
             TypedData::Handle(Z, class_field.kernel_data());
         ASSERT(!kernel_data.IsNull());
         AlternativeReadingScope alt(reader_, &kernel_data, 0);
         intptr_t saved_relative_kernel_offset_ = relative_kernel_offset_;
         relative_kernel_offset_ = class_field.kernel_offset();
         FieldHelper field_helper(this);
@@ skipping 579 matching lines @@
   }
   return new (Z) FlowGraph(*parsed_function(), graph_entry,
                            flow_graph_builder_->next_block_id_ - 1);
 }
 
 FlowGraph* StreamingFlowGraphBuilder::BuildGraph(intptr_t kernel_offset) {
   const 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());
+  const Class& klass =
+      Class::Handle(zone_, parsed_function()->function().Owner());
 
   Function& outermost_function = Function::Handle(Z);
   DiscoverEnclosingElements(Z, function, &outermost_function);
 
   ActiveClassScope active_class_scope(active_class(), &klass);
   ActiveMemberScope active_member(active_class(), &outermost_function);
 
   // 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
@@ skipping 248 matching lines @@
 }
 
 StringIndex StreamingFlowGraphBuilder::ReadNameAsStringIndex() {
   StringIndex name_index = ReadStringReference();  // read name index.
   if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
     ReadUInt();  // read library index.
   }
   return name_index;
 }
 
-const dart::String& StreamingFlowGraphBuilder::ReadNameAsMethodName() {
+const String& StreamingFlowGraphBuilder::ReadNameAsMethodName() {
   StringIndex name_index = ReadStringReference();  // read name index.
   if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
     NameIndex library_reference =
         ReadCanonicalNameReference();  // read library index.
     return H.DartMethodName(library_reference, name_index);
   } else {
     return H.DartMethodName(NameIndex(), name_index);
   }
 }
 
-const dart::String& StreamingFlowGraphBuilder::ReadNameAsSetterName() {
+const String& StreamingFlowGraphBuilder::ReadNameAsSetterName() {
   StringIndex name_index = ReadStringReference();  // read name index.
   if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
     NameIndex library_reference =
         ReadCanonicalNameReference();  // read library index.
     return H.DartSetterName(library_reference, name_index);
   } else {
     return H.DartSetterName(NameIndex(), name_index);
   }
 }
 
-const dart::String& StreamingFlowGraphBuilder::ReadNameAsGetterName() {
+const String& StreamingFlowGraphBuilder::ReadNameAsGetterName() {
   StringIndex name_index = ReadStringReference();  // read name index.
   if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
     NameIndex library_reference =
         ReadCanonicalNameReference();  // read library index.
     return H.DartGetterName(library_reference, name_index);
   } else {
     return H.DartGetterName(NameIndex(), name_index);
   }
 }
 
-const dart::String& StreamingFlowGraphBuilder::ReadNameAsFieldName() {
+const String& StreamingFlowGraphBuilder::ReadNameAsFieldName() {
   StringIndex name_index = ReadStringReference();  // read name index.
   if ((H.StringSize(name_index) >= 1) && H.CharacterAt(name_index, 0) == '_') {
     NameIndex library_reference =
         ReadCanonicalNameReference();  // read library index.
     return H.DartFieldName(library_reference, name_index);
   } else {
     return H.DartFieldName(NameIndex(), name_index);
   }
 }
 
@@ skipping 693 matching lines @@
   intptr_t list_length = ReadListLength();  // read list length.
   for (intptr_t i = 0; i < list_length; ++i) {
     return ReadTag();  // read first tag.
   }
 
   UNREACHABLE();
   return kNothing;
 }
 
 const TypeArguments& StreamingFlowGraphBuilder::PeekArgumentsInstantiatedType(
-    const dart::Class& klass) {
+    const Class& klass) {
   // read parts of arguments, then go back to before doing so.
   AlternativeReadingScope alt(reader_);
   ReadUInt();                               // read argument count.
   intptr_t list_length = ReadListLength();  // read types list length.
   return T.BuildInstantiatedTypeArguments(klass, list_length);  // read types.
 }
 
 intptr_t StreamingFlowGraphBuilder::PeekArgumentsCount() {
   return PeekUInt();
 }
@@ skipping 11 matching lines @@
 
 LocalVariable* StreamingFlowGraphBuilder::LookupVariable(
     intptr_t kernel_offset) {
   return flow_graph_builder_->LookupVariable(kernel_offset);
 }
 
 LocalVariable* StreamingFlowGraphBuilder::MakeTemporary() {
   return flow_graph_builder_->MakeTemporary();
 }
 
-Token::Kind StreamingFlowGraphBuilder::MethodKind(const dart::String& name) {
+Token::Kind StreamingFlowGraphBuilder::MethodKind(const String& name) {
   return flow_graph_builder_->MethodKind(name);
 }
 
-dart::RawFunction* StreamingFlowGraphBuilder::LookupMethodByMember(
+RawFunction* StreamingFlowGraphBuilder::LookupMethodByMember(
     NameIndex target,
-    const dart::String& method_name) {
+    const String& method_name) {
   return flow_graph_builder_->LookupMethodByMember(target, method_name);
 }
 
 bool StreamingFlowGraphBuilder::NeedsDebugStepCheck(const Function& function,
                                                     TokenPosition position) {
   return flow_graph_builder_->NeedsDebugStepCheck(function, position);
 }
 
 bool StreamingFlowGraphBuilder::NeedsDebugStepCheck(Value* value,
                                                     TokenPosition position) {
@@ skipping 55 matching lines @@
                                                const Function& target,
                                                intptr_t argument_count,
                                                const Array& argument_names,
                                                intptr_t type_args_count) {
   return flow_graph_builder_->StaticCall(position, target, argument_count,
                                          argument_names, type_args_count);
 }
 
 Fragment StreamingFlowGraphBuilder::InstanceCall(
     TokenPosition position,
-    const dart::String& name,
+    const String& name,
     Token::Kind kind,
     intptr_t argument_count,
     intptr_t checked_argument_count) {
   return flow_graph_builder_->InstanceCall(position, name, kind, argument_count,
                                            checked_argument_count);
 }
 
 Fragment StreamingFlowGraphBuilder::ThrowException(TokenPosition position) {
   return flow_graph_builder_->ThrowException(position);
 }
 
 Fragment StreamingFlowGraphBuilder::BooleanNegate() {
   return flow_graph_builder_->BooleanNegate();
 }
 
 Fragment StreamingFlowGraphBuilder::TranslateInstantiatedTypeArguments(
     const TypeArguments& type_arguments) {
   return flow_graph_builder_->TranslateInstantiatedTypeArguments(
       type_arguments);
 }
 
 Fragment StreamingFlowGraphBuilder::StrictCompare(Token::Kind kind,
                                                   bool number_check) {
   return flow_graph_builder_->StrictCompare(kind, number_check);
 }
 
 Fragment StreamingFlowGraphBuilder::AllocateObject(TokenPosition position,
-                                                   const dart::Class& klass,
+                                                   const Class& klass,
                                                    intptr_t argument_count) {
   return flow_graph_builder_->AllocateObject(position, klass, argument_count);
 }
 
 Fragment StreamingFlowGraphBuilder::AllocateObject(
-    const dart::Class& klass,
+    const Class& klass,
     const Function& closure_function) {
   return flow_graph_builder_->AllocateObject(klass, closure_function);
 }
 
 Fragment StreamingFlowGraphBuilder::AllocateContext(intptr_t size) {
   return flow_graph_builder_->AllocateContext(size);
 }
 
 Fragment StreamingFlowGraphBuilder::LoadField(intptr_t offset) {
   return flow_graph_builder_->LoadField(offset);
 }
 
 Fragment StreamingFlowGraphBuilder::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) {
   return flow_graph_builder_->InstanceCall(position, name, kind, type_args_len,
                                            argument_count, argument_names,
                                            checked_argument_count);
 }
 
 Fragment StreamingFlowGraphBuilder::StoreLocal(TokenPosition position,
                                                LocalVariable* variable) {
   return flow_graph_builder_->StoreLocal(position, variable);
 }
 
 Fragment StreamingFlowGraphBuilder::StoreStaticField(TokenPosition position,
-                                                     const dart::Field& field) {
+                                                     const Field& field) {
   return flow_graph_builder_->StoreStaticField(position, field);
 }
 
 Fragment StreamingFlowGraphBuilder::StoreInstanceField(TokenPosition position,
                                                        intptr_t offset) {
   return flow_graph_builder_->StoreInstanceField(position, offset);
 }
 
 Fragment StreamingFlowGraphBuilder::StringInterpolate(TokenPosition position) {
   return flow_graph_builder_->StringInterpolate(position);
@@ skipping 102 matching lines @@
 Fragment StreamingFlowGraphBuilder::BuildImplicitClosureCreation(
     const Function& target) {
   return flow_graph_builder_->BuildImplicitClosureCreation(target);
 }
 
 Fragment StreamingFlowGraphBuilder::CheckBooleanInCheckedMode() {
   return flow_graph_builder_->CheckBooleanInCheckedMode();
 }
 
 Fragment StreamingFlowGraphBuilder::CheckAssignableInCheckedMode(
-    const dart::AbstractType& dst_type,
-    const dart::String& dst_name) {
+    const AbstractType& dst_type,
+    const String& dst_name) {
   return flow_graph_builder_->CheckAssignableInCheckedMode(dst_type, dst_name);
 }
 
 Fragment StreamingFlowGraphBuilder::CheckVariableTypeInCheckedMode(
     intptr_t variable_kernel_position) {
   if (I->type_checks()) {
     LocalVariable* variable = LookupVariable(variable_kernel_position);
     return flow_graph_builder_->CheckVariableTypeInCheckedMode(
         variable->type(), variable->name());
   }
   return Fragment();
 }
 
 Fragment StreamingFlowGraphBuilder::CheckVariableTypeInCheckedMode(
     const AbstractType& dst_type,
-    const dart::String& name_symbol) {
+    const String& name_symbol) {
   return flow_graph_builder_->CheckVariableTypeInCheckedMode(dst_type,
                                                              name_symbol);
 }
 
 Fragment StreamingFlowGraphBuilder::EnterScope(intptr_t kernel_offset,
                                                bool* new_context) {
   return flow_graph_builder_->EnterScope(kernel_offset, new_context);
 }
 
 Fragment StreamingFlowGraphBuilder::ExitScope(intptr_t kernel_offset) {
@@ skipping 44 matching lines @@
     if (!skip_push_arguments) instructions += PushArgument();
     if (do_drop) instructions += Drop();
   }
 
   // List of named.
   list_length = ReadListLength();  // read list length.
   if (argument_names != NULL && list_length > 0) {
     *argument_names ^= Array::New(list_length, Heap::kOld);
   }
   for (intptr_t i = 0; i < list_length; ++i) {
-    dart::String& name =
-        H.DartSymbol(ReadStringReference());  // read ith name index.
+    String& name = H.DartSymbol(ReadStringReference());  // read ith name index.
     instructions += BuildExpression();        // read ith expression.
     if (!skip_push_arguments) instructions += PushArgument();
     if (do_drop) instructions += Drop();
     if (argument_names != NULL) {
       argument_names->SetAt(i, name);
     }
   }
 
   return instructions;
 }
@@ skipping 61 matching lines @@
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildPropertyGet(TokenPosition* p) {
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   Fragment instructions = BuildExpression();  // read receiver.
   instructions += PushArgument();
 
-  const dart::String& getter_name = ReadNameAsGetterName();  // read name.
+  const String& getter_name = ReadNameAsGetterName();  // read name.
   SkipCanonicalNameReference();  // Read unused "interface_target_reference".
 
   return instructions + InstanceCall(position, getter_name, Token::kGET, 1);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildPropertySet(TokenPosition* p) {
   Fragment instructions(NullConstant());
   LocalVariable* variable = MakeTemporary();
 
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   instructions += BuildExpression();  // read receiver.
   instructions += PushArgument();
 
-  const dart::String& setter_name = ReadNameAsSetterName();  // read name.
+  const String& setter_name = ReadNameAsSetterName();  // read name.
 
   instructions += BuildExpression();  // read value.
   instructions += StoreLocal(TokenPosition::kNoSource, variable);
   instructions += PushArgument();
 
   SkipCanonicalNameReference();  // read unused "interface_target_reference".
 
   instructions += InstanceCall(position, setter_name, Token::kSET, 2);
   return instructions + Drop();
 }
@@ skipping 14 matching lines @@
       // Undo stack change for the BuildExpression.
       Pop();
 
       target = LookupMethodByMember(kernel_name, H.DartMethodName(kernel_name));
       target = target.ImplicitClosureFunction();
       ASSERT(!target.IsNull());
       return BuildImplicitClosureCreation(target);
     }
   } else {
     ASSERT(H.IsField(kernel_name));
-    const dart::String& getter_name = H.DartGetterName(kernel_name);
+    const String& getter_name = H.DartGetterName(kernel_name);
     target = LookupMethodByMember(kernel_name, getter_name);
     ASSERT(target.IsGetterFunction() || target.IsImplicitGetterFunction());
   }
 
   instructions += PushArgument();
   return instructions + StaticCall(position, target, 1);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildDirectPropertySet(TokenPosition* p) {
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   Fragment instructions(NullConstant());
   LocalVariable* value = MakeTemporary();
 
   instructions += BuildExpression();  // read receiver.
   instructions += PushArgument();
 
   NameIndex target_reference =
       ReadCanonicalNameReference();  // read target_reference.
-  const dart::String& method_name = H.DartSetterName(target_reference);
+  const String& method_name = H.DartSetterName(target_reference);
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(target_reference, method_name));
   ASSERT(target.IsSetterFunction() || target.IsImplicitSetterFunction());
 
   instructions += BuildExpression();  // read value.
   instructions += StoreLocal(TokenPosition::kNoSource, value);
   instructions += PushArgument();
 
   instructions += StaticCall(position, target, 2);
 
   return instructions + Drop();
 }
 
 Fragment StreamingFlowGraphBuilder::BuildStaticGet(TokenPosition* p) {
   intptr_t offset = ReaderOffset() - 1;  // Include the tag.
 
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   NameIndex target = ReadCanonicalNameReference();  // read target_reference.
 
   if (H.IsField(target)) {
-    const dart::Field& field =
-        dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
+    const Field& field =
+        Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     if (field.is_const()) {
       return Constant(constant_evaluator_.EvaluateExpression(offset));
     } else {
-      const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
-      const dart::String& getter_name = H.DartGetterName(target);
+      const Class& owner = Class::Handle(Z, field.Owner());
+      const 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);
         return instructions + LoadStaticField();
       } else {
         return StaticCall(position, getter, 0);
       }
     }
   } else {
@@ skipping 12 matching lines @@
   return Fragment();
 }
 
 Fragment StreamingFlowGraphBuilder::BuildStaticSet(TokenPosition* p) {
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   NameIndex target = ReadCanonicalNameReference();  // read target_reference.
 
   if (H.IsField(target)) {
-    const dart::Field& field =
-        dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
+    const Field& field =
+        Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
     Fragment instructions = BuildExpression();  // read expression.
     if (NeedsDebugStepCheck(stack(), position)) {
       instructions = DebugStepCheck(position) + instructions;
     }
     instructions += CheckAssignableInCheckedMode(
-        dst_type, dart::String::ZoneHandle(Z, field.name()));
+        dst_type, String::ZoneHandle(Z, field.name()));
     LocalVariable* variable = MakeTemporary();
     instructions += LoadLocal(variable);
     return instructions + StoreStaticField(position, field);
   } else {
     ASSERT(H.IsProcedure(target));
 
     // Evaluate the expression on the right hand side.
     Fragment instructions = BuildExpression();  // read expression.
     LocalVariable* variable = MakeTemporary();
 
@@ skipping 20 matching lines @@
   intptr_t offset = ReaderOffset() - 1;     // Include the tag.
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   Tag receiver_tag = PeekTag();  // peek tag for receiver.
   if (IsNumberLiteral(receiver_tag)) {
     intptr_t before_branch_offset = ReaderOffset();
 
     SkipExpression();  // read receiver (it's just a number literal).
 
-    const dart::String& name = ReadNameAsMethodName();  // read name.
+    const String& name = ReadNameAsMethodName();  // read name.
     const Token::Kind token_kind = MethodKind(name);
     intptr_t argument_count = PeekArgumentsCount() + 1;
 
     if ((argument_count == 1) && (token_kind == Token::kNEGATE)) {
       const Object& result = constant_evaluator_.EvaluateExpressionSafe(offset);
       if (!result.IsError()) {
         SkipArguments();  // read arguments,
         // read unused "interface_target_reference".
         SkipCanonicalNameReference();
         return Constant(result);
       }
     } else if ((argument_count == 2) &&
                Token::IsBinaryArithmeticOperator(token_kind) &&
                IsNumberLiteral(PeekArgumentsFirstPositionalTag())) {
       const Object& result = constant_evaluator_.EvaluateExpressionSafe(offset);
       if (!result.IsError()) {
         SkipArguments();
         // read unused "interface_target_reference".
         SkipCanonicalNameReference();
         return Constant(result);
       }
     }
 
     SetOffset(before_branch_offset);
   }
 
   Fragment instructions = BuildExpression();  // read receiver.
 
-  const dart::String& name = ReadNameAsMethodName();  // read name.
+  const String& name = ReadNameAsMethodName();  // read name.
   const Token::Kind token_kind = MethodKind(name);
 
   // Detect comparison with null.
   if ((token_kind == Token::kEQ || token_kind == Token::kNE) &&
       PeekArgumentsCount() == 1 &&
       (receiver_tag == kNullLiteral ||
        PeekArgumentsFirstPositionalTag() == kNullLiteral)) {
     // "==" or "!=" with null on either side.
     instructions += BuildArguments(NULL, NULL, true);  // read arguments.
     SkipCanonicalNameReference();  // read unused "interface_target_reference".
@@ skipping 41 matching lines @@
 Fragment StreamingFlowGraphBuilder::BuildDirectMethodInvocation(
     TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   // TODO(28109) Support generic methods in the VM or reify them away.
   Tag receiver_tag = PeekTag();               // peek tag for receiver.
   Fragment instructions = BuildExpression();  // read receiver.
 
   NameIndex kernel_name =
       ReadCanonicalNameReference();  // read target_reference.
-  const dart::String& method_name = H.DartProcedureName(kernel_name);
+  const String& method_name = H.DartProcedureName(kernel_name);
   const Token::Kind token_kind = MethodKind(method_name);
 
   // Detect comparison with null.
   if ((token_kind == Token::kEQ || token_kind == Token::kNE) &&
       PeekArgumentsCount() == 1 &&
       (receiver_tag == kNullLiteral ||
        PeekArgumentsFirstPositionalTag() == kNullLiteral)) {
     // "==" or "!=" with null on either side.
     instructions += BuildArguments(NULL, NULL, true);  // read arguments.
     Token::Kind strict_cmp_kind =
@@ skipping 19 matching lines @@
 Fragment StreamingFlowGraphBuilder::BuildStaticInvocation(bool is_const,
                                                           TokenPosition* p) {
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   NameIndex procedue_reference =
       ReadCanonicalNameReference();  // read procedure reference.
   intptr_t argument_count = PeekArgumentsCount();
   const Function& target = Function::ZoneHandle(
       Z, H.LookupStaticMethodByKernelProcedure(procedue_reference));
-  const dart::Class& klass = dart::Class::ZoneHandle(Z, target.Owner());
+  const Class& klass = Class::ZoneHandle(Z, target.Owner());
   if (target.IsGenerativeConstructor() || target.IsFactory()) {
     // The VM requires a TypeArguments object as first parameter for
     // every factory constructor.
     ++argument_count;
   }
 
   Fragment instructions;
   LocalVariable* instance_variable = NULL;
 
   // If we cross the Kernel -> VM core library boundary, a [StaticInvocation]
@@ skipping 26 matching lines @@
     //
     // TODO(27590): Get rid of this after we're using core libraries compiled
     // into Kernel.
     const TypeArguments& type_arguments = PeekArgumentsInstantiatedType(klass);
     instructions += TranslateInstantiatedTypeArguments(type_arguments);
     instructions += PushArgument();
   } else {
     // TODO(28109) Support generic methods in the VM or reify them away.
   }
 
-  bool special_case_identical =
-      klass.IsTopLevel() && (klass.library() == dart::Library::CoreLibrary()) &&
-      (target.name() == Symbols::Identical().raw());
+  bool special_case_identical = klass.IsTopLevel() &&
+                                (klass.library() == Library::CoreLibrary()) &&
+                                (target.name() == Symbols::Identical().raw());
 
   Array& argument_names = Array::ZoneHandle(Z);
   instructions += BuildArguments(&argument_names, NULL,
                                  special_case_identical);  // read arguments.
   const int kTypeArgsLen = 0;
   ASSERT(target.AreValidArguments(kTypeArgsLen, argument_count, argument_names,
                                   NULL));
 
   // Special case identical(x, y) call.
   // TODO(27590) consider moving this into the inliner and force inline it
@@ skipping 25 matching lines @@
     SkipExpression();  // read past this ConstructorInvocation.
     return Constant(constant_evaluator_.EvaluateConstructorInvocation(offset));
   }
 
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   NameIndex kernel_name =
       ReadCanonicalNameReference();  // read target_reference.
 
-  dart::Class& klass = dart::Class::ZoneHandle(
+  Class& klass = Class::ZoneHandle(
       Z, H.LookupClassByKernelClass(H.EnclosingName(kernel_name)));
 
   Fragment instructions;
 
   // Check for malbounded-ness of type.
   if (I->type_checks()) {
     intptr_t offset = ReaderOffset();
 
     const TypeArguments& type_arguments = BuildTypeArguments();
 
@@ skipping 204 matching lines @@
     // Let condition be always true.
     instructions += Constant(Bool::True());
   } else {
     instructions += PushArgument();
 
     // See if simple instanceOf is applicable.
     if (dart::FlowGraphBuilder::SimpleInstanceOfType(type)) {
       instructions += Constant(type);
       instructions += PushArgument();  // Type.
       instructions += InstanceCall(
-          position,
-          dart::Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()),
+          position, Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()),
           Token::kIS, 2, 2);  // 2 checked arguments.
       return instructions;
     }
 
     if (!type.IsInstantiated(kCurrentClass)) {
       instructions += LoadInstantiatorTypeArguments();
     } else {
       instructions += NullConstant();
     }
     instructions += PushArgument();  // Instantiator type arguments.
 
     if (!type.IsInstantiated(kFunctions)) {
       instructions += LoadFunctionTypeArguments();
     } else {
       instructions += NullConstant();
     }
     instructions += PushArgument();  // Function type arguments.
 
     instructions += Constant(type);
     instructions += PushArgument();  // Type.
 
     instructions += InstanceCall(
-        position, dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
+        position, Library::PrivateCoreLibName(Symbols::_instanceOf()),
         Token::kIS, 4);
   }
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildAsExpression(TokenPosition* p) {
   TokenPosition position = ReadPosition();  // read position.
   if (p != NULL) *p = position;
 
   Fragment instructions = BuildExpression();  // read operand.
@@ skipping 28 matching lines @@
       instructions += LoadFunctionTypeArguments();
     } else {
       instructions += NullConstant();
     }
     instructions += PushArgument();  // Function type arguments.
 
     instructions += Constant(type);
     instructions += PushArgument();  // Type.
 
     instructions += InstanceCall(
-        position, dart::Library::PrivateCoreLibName(Symbols::_as()), Token::kAS,
-        4);
+        position, Library::PrivateCoreLibName(Symbols::_as()), Token::kAS, 4);
   }
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildSymbolLiteral(
     TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   intptr_t offset = ReaderOffset() - 1;  // EvaluateExpression needs the tag.
   SkipStringReference();                 // read index into string table.
@@ skipping 108 matching lines @@
       instructions += IntConstant(i);
       instructions += BuildExpression();  // read ith expression.
       instructions += CheckAssignableInCheckedMode(
           list_type, Symbols::ListLiteralElement());
       instructions += StoreIndexed(kArrayCid);
       instructions += Drop();
     }
   }
   instructions += PushArgument();  // The array.
 
-  const dart::Class& factory_class =
-      dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::List()));
+  const Class& factory_class =
+      Class::Handle(Z, Library::LookupCoreClass(Symbols::List()));
   const Function& factory_method = Function::ZoneHandle(
       Z, factory_class.LookupFactory(
-             dart::Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
+             Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
 
   return instructions + StaticCall(position, factory_method, 2);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildMapLiteral(bool is_const,
                                                     TokenPosition* p) {
   if (is_const) {
     intptr_t offset = ReaderOffset() - 1;  // Include the tag.
     (p != NULL) ? * p = ReadPosition() : ReadPosition();
 
@@ skipping 35 matching lines @@
 
       instructions += LoadLocal(array);
       instructions += IntConstant(2 * i + 1);
       instructions += BuildExpression();  // read ith value.
       instructions += StoreIndexed(kArrayCid);
       instructions += Drop();
     }
   }
   instructions += PushArgument();  // The array.
 
-  const dart::Class& map_class =
-      dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::Map()));
+  const Class& map_class =
+      Class::Handle(Z, Library::LookupCoreClass(Symbols::Map()));
   const Function& factory_method = Function::ZoneHandle(
       Z, map_class.LookupFactory(
-             dart::Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
+             Library::PrivateCoreLibName(Symbols::MapLiteralFactory())));
 
   return instructions + StaticCall(position, factory_method, 2);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildFunctionExpression() {
   ReadPosition();  // read position.
   return BuildFunctionNode(TokenPosition::kNoSource, StringIndex());
 }
 
 Fragment StreamingFlowGraphBuilder::BuildLet(TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   Fragment instructions = BuildVariableDeclaration();  // read variable.
   instructions += BuildExpression();                   // read body.
   return instructions;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildBigIntLiteral(
     TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
-  const dart::String& value =
+  const String& value =
       H.DartString(ReadStringReference());  // read index into string table.
   const Integer& integer =
       Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld));
   if (integer.IsNull()) {
     H.ReportError("Integer literal %s is out of range", value.ToCString());
     UNREACHABLE();
   }
   return Constant(integer);
 }
 
@@ skipping 96 matching lines @@
     TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   NameIndex function_reference =
       ReadCanonicalNameReference();  // read function reference.
   Function& function = Function::ZoneHandle(
       Z, H.LookupStaticMethodByKernelProcedure(function_reference));
   function = function.ConvertedClosureFunction();
   ASSERT(!function.IsNull());
 
-  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 instructions = AllocateObject(closure_class, function);
   LocalVariable* closure = MakeTemporary();
 
   instructions += BuildExpression();  // read context vector.
   LocalVariable* context = MakeTemporary();
 
   instructions += LoadLocal(closure);
   instructions += Constant(function);
   instructions +=
       StoreInstanceField(TokenPosition::kNoSource, Closure::function_offset());
@@ skipping 85 matching lines @@
   instructions += EvaluateAssertion();
   instructions += CheckBooleanInCheckedMode();
   instructions += Constant(Bool::True());
   instructions += BranchIfEqual(&then, &otherwise, false);
 
   TokenPosition condition_start_offset =
       ReadPosition();  // read condition start offset.
   TokenPosition condition_end_offset =
       ReadPosition();  // read condition end offset.
 
-  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 dart::Function& target = dart::Function::ZoneHandle(
+  const Function& target = Function::ZoneHandle(
       Z, klass.LookupStaticFunctionAllowPrivate(Symbols::ThrowNew()));
   ASSERT(!target.IsNull());
 
   // Build call to _AsertionError._throwNew(start, end, message)
   Fragment otherwise_fragment(otherwise);
   otherwise_fragment += IntConstant(condition_start_offset.Pos());
   otherwise_fragment += PushArgument();  // start
   otherwise_fragment += IntConstant(condition_end_offset.Pos());
   otherwise_fragment += PushArgument();  // end
   Tag tag = ReadTag();                   // read (first part of) message.
@@ skipping 183 matching lines @@
   ReadPosition();                                // read position.
   TokenPosition body_position = ReadPosition();  // read body position.
   intptr_t variable_kernel_position = ReaderOffset() + relative_kernel_offset_;
   SkipVariableDeclaration();  // read variable.
 
   TokenPosition iterable_position = TokenPosition::kNoSource;
   Fragment instructions =
       BuildExpression(&iterable_position);  // read iterable.
   instructions += PushArgument();
 
-  const dart::String& iterator_getter = dart::String::ZoneHandle(
-      Z, dart::Field::GetterSymbol(Symbols::Iterator()));
+  const String& iterator_getter =
+      String::ZoneHandle(Z, Field::GetterSymbol(Symbols::Iterator()));
   instructions +=
       InstanceCall(iterable_position, iterator_getter, Token::kGET, 1);
   LocalVariable* iterator = scopes()->iterator_variables[for_in_depth()];
   instructions += StoreLocal(TokenPosition::kNoSource, iterator);
   instructions += Drop();
 
   for_in_depth_inc();
   loop_depth_inc();
   Fragment condition = LoadLocal(iterator);
   condition += PushArgument();
   condition +=
       InstanceCall(iterable_position, Symbols::MoveNext(), Token::kILLEGAL, 1);
   TargetEntryInstr* body_entry;
   TargetEntryInstr* loop_exit;
   condition += BranchIfTrue(&body_entry, &loop_exit, false);
 
   Fragment body(body_entry);
   body += EnterScope(offset + relative_kernel_offset_);
   body += LoadLocal(iterator);
   body += PushArgument();
-  const dart::String& current_getter = dart::String::ZoneHandle(
-      Z, dart::Field::GetterSymbol(Symbols::Current()));
+  const String& current_getter =
+      String::ZoneHandle(Z, Field::GetterSymbol(Symbols::Current()));
   body += InstanceCall(body_position, current_getter, Token::kGET, 1);
   body += StoreLocal(TokenPosition::kNoSource,
                      LookupVariable(variable_kernel_position));
   body += Drop();
   body += BuildStatement();  // read body.
   body += ExitScope(offset + relative_kernel_offset_);
 
   if (body.is_open()) {
     JoinEntryInstr* join = BuildJoinEntry();
     instructions += Goto(join);
@@ skipping 51 matching lines @@
 
     if (body_fragment.entry == NULL) {
       // Make a NOP in order to ensure linking works properly.
       body_fragment = NullConstant();
       body_fragment += Drop();
     }
 
     // The Dart language specification mandates fall-throughs in [SwitchCase]es
     // to be runtime errors.
     if (!is_default && body_fragment.is_open() && (i < (case_count - 1))) {
-      const dart::Class& klass = dart::Class::ZoneHandle(
-          Z, dart::Library::LookupCoreClass(Symbols::FallThroughError()));
+      const Class& klass = Class::ZoneHandle(
+          Z, Library::LookupCoreClass(Symbols::FallThroughError()));
       ASSERT(!klass.IsNull());
-      const dart::Function& constructor = dart::Function::ZoneHandle(
+      const Function& constructor = Function::ZoneHandle(
           Z, klass.LookupConstructorAllowPrivate(
                  H.DartSymbol("FallThroughError._create")));
       ASSERT(!constructor.IsNull());
-      const dart::String& url = H.DartString(
+      const String& url = H.DartString(
           parsed_function()->function().ToLibNamePrefixedQualifiedCString(),
           Heap::kOld);
 
       // Create instance of _FallThroughError
       body_fragment += AllocateObject(TokenPosition::kNoSource, klass, 0);
       LocalVariable* instance = MakeTemporary();
 
       // Call _FallThroughError._create constructor.
       body_fragment += LoadLocal(instance);
       body_fragment += PushArgument();  // this
@@ skipping 307 matching lines @@
         if (!type_guard->IsInstantiated(kFunctions)) {
           catch_body += LoadFunctionTypeArguments();
         } else {
           catch_body += NullConstant();
         }
         catch_body += PushArgument();  // function type arguments
         catch_body += Constant(*type_guard);
         catch_body += PushArgument();  // guard type
         catch_body += InstanceCall(
             TokenPosition::kNoSource,
-            dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
-            Token::kIS, 4);
+            Library::PrivateCoreLibName(Symbols::_instanceOf()), Token::kIS, 4);
 
         TargetEntryInstr* catch_entry;
         TargetEntryInstr* next_catch_entry;
         catch_body += BranchIfTrue(&catch_entry, &next_catch_entry, false);
 
         Fragment(catch_entry) + catch_handler_body;
         catch_body = Fragment(next_catch_entry);
       }
     } else {
       catch_body += catch_handler_body;
@@ skipping 177 matching lines @@
 
   return continuation;
 }
 
 Fragment StreamingFlowGraphBuilder::BuildVariableDeclaration() {
   intptr_t kernel_position_no_tag = ReaderOffset() + relative_kernel_offset_;
   LocalVariable* variable = LookupVariable(kernel_position_no_tag);
 
   VariableDeclarationHelper helper(this);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kType);
-  dart::String& name = H.DartSymbol(helper.name_index_);
+  String& name = H.DartSymbol(helper.name_index_);
   AbstractType& type = T.BuildType();  // read type.
   Tag tag = ReadTag();                 // read (first part of) initializer.
 
   Fragment instructions;
   if (tag == kNothing) {
     instructions += NullConstant();
   } else {
     if (helper.IsConst()) {
       const Instance& constant_value = constant_evaluator_.EvaluateExpression(
           ReaderOffset());  // read initializer form current position.
@@ skipping 61 matching lines @@
   Function& function = Function::ZoneHandle(Z);
 
   // NOTE: This is not TokenPosition in the general sense!
   function = I->LookupClosureFunction(parsed_function()->function(), position);
   if (function.IsNull()) {
     for (intptr_t i = 0; i < scopes()->function_scopes.length(); ++i) {
       if (scopes()->function_scopes[i].kernel_offset != offset) {
         continue;
       }
 
-      const dart::String* name;
+      const String* name;
       if (declaration) {
         name = &H.DartSymbol(name_index);
       } else {
         name = &Symbols::AnonymousClosure();
       }
       // NOTE: This is not TokenPosition in the general sense!
       function = Function::NewClosureFunction(
           *name, parsed_function()->function(), position);
 
       function.set_is_debuggable(function_node_helper.dart_async_marker_ ==
@@ skipping 19 matching lines @@
       if (function.IsAsyncClosure() || function.IsAsyncGenClosure()) {
         function.set_is_inlinable(!FLAG_causal_async_stacks);
       }
 
       function.set_end_token_pos(function_node_helper.end_position_);
       LocalScope* scope = scopes()->function_scopes[i].scope;
       const ContextScope& context_scope = ContextScope::Handle(
           Z, scope->PreserveOuterScope(flow_graph_builder_->context_depth_));
       function.set_context_scope(context_scope);
       function.set_kernel_offset(offset);
-      SetupFunctionParameters(dart::Class::Handle(Z), function,
+      SetupFunctionParameters(Class::Handle(Z), function,
                               false,  // is_method
                               true,   // is_closure
                               &function_node_helper);
       function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
       TypedData& kernel_data = reader_->CopyDataToVMHeap(
           Z, offset - relative_kernel_offset_, ReaderOffset());
       function.set_kernel_data(kernel_data);
 
       // Finalize function type.
       Type& signature_type = Type::Handle(Z, function.SignatureType());
       signature_type ^=
           ClassFinalizer::FinalizeType(*active_class()->klass, signature_type);
       function.SetSignatureType(signature_type);
 
       I->AddClosureFunction(function);
       break;
     }
   }
 
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
 
-  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());
   ASSERT(!closure_class.IsNull());
   Fragment instructions =
       flow_graph_builder_->AllocateObject(closure_class, function);
   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 (!function.HasInstantiatedSignature(kCurrentClass)) {
@@ skipping 12 matching lines @@
 
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function()->current_context_var());
   instructions += flow_graph_builder_->StoreInstanceField(
       TokenPosition::kNoSource, Closure::context_offset());
 
   return instructions;
 }
 
 void StreamingFlowGraphBuilder::SetupFunctionParameters(
-    const dart::Class& klass,
-    const dart::Function& function,
+    const Class& klass,
+    const Function& function,
     bool is_method,
     bool is_closure,
     FunctionNodeHelper* function_node_helper) {
   ASSERT(!(is_method && is_closure));
   bool is_factory = function.IsFactory();
   intptr_t extra_parameters = (is_method || is_closure || is_factory) ? 1 : 0;
 
   function_node_helper->ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);
 
@@ skipping 290 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)