Do not qualify with dart:: except where necessary

runtime/vm/kernel_binary_flowgraph.h

 // Copyright (c) 2017, 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.
 
 #ifndef RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_
 #define RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
@@ skipping 434 matching lines @@
   // Is guaranteed to be not malformed.
   AbstractType& BuildVariableType();
 
   // Will return `TypeArguments::null()` in case any of the arguments are
   // malformed.
   const TypeArguments& BuildTypeArguments(intptr_t length);
 
   // Will return `TypeArguments::null()` in case any of the arguments are
   // malformed.
   const TypeArguments& BuildInstantiatedTypeArguments(
-      const dart::Class& receiver_class,
+      const Class& receiver_class,
       intptr_t length);
 
-  const Type& ReceiverType(const dart::Class& klass);
+  const Type& ReceiverType(const Class& klass);
 
  private:
   // Can build a malformed type.
   void BuildTypeInternal();
   void BuildInterfaceType(bool simple);
   void BuildFunctionType(bool simple);
   void BuildTypeParameterType();
 
   class TypeParameterScope {
    public:
@@ skipping 74 matching lines @@
    */
   void AddPositionalAndNamedParameters(intptr_t pos = 0);
   /**
    * This assumes that the reader is at a FunctionNode,
    * about to read a parameter (i.e. VariableDeclaration).
    */
   void AddVariableDeclarationParameter(intptr_t pos);
 
   LocalVariable* MakeVariable(TokenPosition declaration_pos,
                               TokenPosition token_pos,
-                              const dart::String& name,
+                              const String& name,
                               const AbstractType& type);
 
   void AddExceptionVariable(GrowableArray<LocalVariable*>* variables,
                             const char* prefix,
                             intptr_t nesting_depth);
 
   void AddTryVariables();
   void AddCatchVariables();
   void AddIteratorVariable();
   void AddSwitchVariable();
 
   // Record an assignment or reference to a variable.  If the occurrence is
   // in a nested function, ensure that the variable is handled properly as a
   // captured variable.
   void LookupVariable(intptr_t declaration_binary_offset);
 
-  const dart::String& GenerateName(const char* prefix, intptr_t suffix);
+  const String& GenerateName(const char* prefix, intptr_t suffix);
 
-  void HandleSpecialLoad(LocalVariable** variable, const dart::String& symbol);
+  void HandleSpecialLoad(LocalVariable** variable, const String& symbol);
   void LookupCapturedVariableByName(LocalVariable** variable,
-                                    const dart::String& name);
+                                    const String& name);
 
   struct DepthState {
     explicit DepthState(intptr_t function)
         : loop_(0),
           function_(function),
           try_(0),
           catch_(0),
           finally_(0),
           for_in_(0) {}
 
@@ skipping 87 matching lines @@
 
   const Object& RunFunction(const Function& function,
                             intptr_t argument_count,
                             const Instance* receiver,
                             const TypeArguments* type_args);
 
   const Object& RunFunction(const Function& function,
                             const Array& arguments,
                             const Array& names);
 
-  RawObject* EvaluateConstConstructorCall(const dart::Class& type_class,
+  RawObject* EvaluateConstConstructorCall(const Class& type_class,
                                           const TypeArguments& type_arguments,
                                           const Function& constructor,
                                           const Object& argument);
 
   const TypeArguments* TranslateTypeArguments(const Function& target,
-                                              dart::Class* target_klass);
+                                              Class* target_klass);
 
   void AssertBool() {
     if (!result_.IsBool()) {
       translation_helper_.ReportError("Expected boolean expression.");
     }
   }
 
   bool EvaluateBooleanExpressionHere();
 
   bool GetCachedConstant(intptr_t kernel_offset, Instance* value);
@@ skipping 100 matching lines @@
   void SetOffset(intptr_t offset);
   void SkipBytes(intptr_t skip);
   bool ReadBool();
   uint8_t ReadByte();
   uint32_t ReadUInt();
   uint32_t PeekUInt();
   intptr_t ReadListLength();
   StringIndex ReadStringReference();
   NameIndex ReadCanonicalNameReference();
   StringIndex ReadNameAsStringIndex();
-  const dart::String& ReadNameAsMethodName();
-  const dart::String& ReadNameAsGetterName();
-  const dart::String& ReadNameAsSetterName();
-  const dart::String& ReadNameAsFieldName();
+  const String& ReadNameAsMethodName();
+  const String& ReadNameAsGetterName();
+  const String& ReadNameAsSetterName();
+  const String& ReadNameAsFieldName();
   void SkipStringReference();
   void SkipCanonicalNameReference();
   void SkipDartType();
   void SkipOptionalDartType();
   void SkipInterfaceType(bool simple);
   void SkipFunctionType(bool simple);
   void SkipListOfExpressions();
   void SkipListOfDartTypes();
   void SkipListOfStrings();
   void SkipListOfVariableDeclarations();
@@ skipping 36 matching lines @@
   ParsedFunction* parsed_function();
   TryFinallyBlock* try_finally_block();
   SwitchBlock* switch_block();
   BreakableBlock* breakable_block();
   GrowableArray<YieldContinuation>& yield_continuations();
   Value* stack();
   void Push(Definition* definition);
   Value* Pop();
 
   Tag PeekArgumentsFirstPositionalTag();
-  const TypeArguments& PeekArgumentsInstantiatedType(const dart::Class& klass);
+  const TypeArguments& PeekArgumentsInstantiatedType(const Class& klass);
   intptr_t PeekArgumentsCount();
   intptr_t PeekArgumentsTypeCount();
   void SkipArgumentsBeforeActualArguments();
 
   LocalVariable* LookupVariable(intptr_t kernel_offset);
   LocalVariable* MakeTemporary();
-  Token::Kind MethodKind(const dart::String& name);
-  dart::RawFunction* LookupMethodByMember(NameIndex target,
-                                          const dart::String& method_name);
+  Token::Kind MethodKind(const String& name);
+  RawFunction* LookupMethodByMember(NameIndex target,
+                                    const String& method_name);
 
   bool NeedsDebugStepCheck(const Function& function, TokenPosition position);
   bool NeedsDebugStepCheck(Value* value, TokenPosition position);
 
   void InlineBailout(const char* reason);
   Fragment DebugStepCheck(TokenPosition position);
   Fragment LoadLocal(LocalVariable* variable);
   Fragment Return(TokenPosition position);
   Fragment PushArgument();
   Fragment EvaluateAssertion();
   Fragment RethrowException(TokenPosition position, int catch_try_index);
   Fragment ThrowNoSuchMethodError();
   Fragment Constant(const Object& value);
   Fragment IntConstant(int64_t value);
   Fragment LoadStaticField();
   Fragment StaticCall(TokenPosition position,
                       const Function& target,
                       intptr_t argument_count);
   Fragment StaticCall(TokenPosition position,
                       const Function& target,
                       intptr_t argument_count,
                       const Array& argument_names,
                       intptr_t type_args_len = 0);
   Fragment InstanceCall(TokenPosition position,
-                        const dart::String& name,
+                        const String& name,
                         Token::Kind kind,
                         intptr_t argument_count,
                         intptr_t checked_argument_count = 1);
   Fragment 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);
   Fragment ThrowException(TokenPosition position);
   Fragment BooleanNegate();
   Fragment TranslateInstantiatedTypeArguments(
       const TypeArguments& type_arguments);
   Fragment StrictCompare(Token::Kind kind, bool number_check = false);
   Fragment AllocateObject(TokenPosition position,
-                          const dart::Class& klass,
+                          const Class& klass,
                           intptr_t argument_count);
-  Fragment AllocateObject(const dart::Class& klass,
-                          const Function& closure_function);
+  Fragment AllocateObject(const Class& klass, const Function& closure_function);
   Fragment AllocateContext(intptr_t size);
   Fragment LoadField(intptr_t offset);
   Fragment StoreLocal(TokenPosition position, LocalVariable* variable);
-  Fragment StoreStaticField(TokenPosition position, const dart::Field& field);
+  Fragment StoreStaticField(TokenPosition position, const Field& field);
   Fragment StoreInstanceField(TokenPosition position, intptr_t offset);
   Fragment StringInterpolate(TokenPosition position);
   Fragment StringInterpolateSingle(TokenPosition position);
   Fragment ThrowTypeError();
   Fragment LoadInstantiatorTypeArguments();
   Fragment LoadFunctionTypeArguments();
   Fragment InstantiateType(const AbstractType& type);
   Fragment CreateArray();
   Fragment StoreIndexed(intptr_t class_id);
   Fragment CheckStackOverflow();
@@ skipping 13 matching lines @@
                            intptr_t handler_index,
                            bool needs_stacktrace);
   Fragment TryCatch(int try_handler_index);
   Fragment Drop();
   Fragment NullConstant();
   JoinEntryInstr* BuildJoinEntry();
   JoinEntryInstr* BuildJoinEntry(intptr_t try_index);
   Fragment Goto(JoinEntryInstr* destination);
   Fragment BuildImplicitClosureCreation(const Function& target);
   Fragment CheckBooleanInCheckedMode();
-  Fragment CheckAssignableInCheckedMode(const dart::AbstractType& dst_type,
-                                        const dart::String& dst_name);
+  Fragment CheckAssignableInCheckedMode(const AbstractType& dst_type,
+                                        const String& dst_name);
   Fragment CheckVariableTypeInCheckedMode(intptr_t variable_kernel_position);
   Fragment CheckVariableTypeInCheckedMode(const AbstractType& dst_type,
-                                          const dart::String& name_symbol);
+                                          const String& name_symbol);
   Fragment EnterScope(intptr_t kernel_offset, bool* new_context = NULL);
   Fragment ExitScope(intptr_t kernel_offset);
 
   Fragment TranslateCondition(bool* negate);
   const TypeArguments& BuildTypeArguments();
   Fragment BuildArguments(Array* argument_names,
                           intptr_t* argument_count,
                           bool skip_push_arguments = false,
                           bool do_drop = false);
   Fragment BuildArgumentsFromActualArguments(Array* argument_names,
@@ skipping 58 matching lines @@
   Fragment BuildContinueSwitchStatement();
   Fragment BuildIfStatement();
   Fragment BuildReturnStatement();
   Fragment BuildTryCatch();
   Fragment BuildTryFinally();
   Fragment BuildYieldStatement();
   Fragment BuildVariableDeclaration();
   Fragment BuildFunctionDeclaration();
   Fragment BuildFunctionNode(TokenPosition parent_position,
                              StringIndex name_index);
-  void SetupFunctionParameters(const dart::Class& klass,
-                               const dart::Function& function,
+  void SetupFunctionParameters(const Class& klass,
+                               const Function& function,
                                bool is_method,
                                bool is_closure,
                                FunctionNodeHelper* function_node_helper);
 
   FlowGraphBuilder* flow_graph_builder_;
   TranslationHelper& translation_helper_;
   Zone* zone_;
   Reader* reader_;
   StreamingConstantEvaluator constant_evaluator_;
   StreamingDartTypeTranslator type_translator_;
@@ skipping 66 matching lines @@
   const uint8_t* saved_raw_buffer_;
   const TypedData* saved_typed_data_;
   intptr_t saved_offset_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_