Remove some "namespace" classes from C++ Kernel

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/kernel_binary.h"
@@ skipping 592 matching lines @@
   function.set_kernel_offset(procedure_offset);
 
   ActiveMemberScope active_member(&active_class_, &function);
 
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kFunction);
   Tag function_node_tag = builder_.ReadTag();
   ASSERT(function_node_tag == kSomething);
   FunctionNodeHelper function_node_helper(&builder_);
   function_node_helper.ReadUntilIncluding(FunctionNodeHelper::kDartAsyncMarker);
   function.set_is_debuggable(function_node_helper.dart_async_marker_ ==
-                             FunctionNode::kSync);
+                             FunctionNodeHelper::kSync);
   switch (function_node_helper.dart_async_marker_) {
-    case FunctionNode::kSyncStar:
+    case FunctionNodeHelper::kSyncStar:
       function.set_modifier(RawFunction::kSyncGen);
       break;
-    case FunctionNode::kAsync:
+    case FunctionNodeHelper::kAsync:
       function.set_modifier(RawFunction::kAsync);
       function.set_is_inlinable(!FLAG_causal_async_stacks);
       break;
-    case FunctionNode::kAsyncStar:
+    case FunctionNodeHelper::kAsyncStar:
       function.set_modifier(RawFunction::kAsyncGen);
       function.set_is_inlinable(!FLAG_causal_async_stacks);
       break;
     default:
       // no special modifier
       break;
   }
-  ASSERT(function_node_helper.async_marker_ == FunctionNode::kSync);
+  ASSERT(function_node_helper.async_marker_ == FunctionNodeHelper::kSync);
 
   if (native_name != NULL) {
     function.set_native_name(*native_name);
   }
 
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kTypeParameters);
   if (!function.IsFactory()) {
     // Read type_parameters list length.
     intptr_t type_parameter_count = builder_.ReadListLength();
     // Set type parameters.
@@ skipping 271 matching lines @@
     }
     // Insert the class in the cache before calling ReadPreliminaryClass so
     // we do not risk allocating the class again by calling LookupClass
     // recursively from ReadPreliminaryClass for the same class.
     classes_.Insert(klass, handle);
   }
   return *handle;
 }
 
 RawFunction::Kind KernelReader::GetFunctionType(
-    Procedure::ProcedureKind procedure_kind) {
+    ProcedureHelper::Kind procedure_kind) {
   intptr_t lookuptable[] = {
       RawFunction::kRegularFunction,  // Procedure::kMethod
       RawFunction::kGetterFunction,   // Procedure::kGetter
       RawFunction::kSetterFunction,   // Procedure::kSetter
       RawFunction::kRegularFunction,  // Procedure::kOperator
       RawFunction::kConstructor,      // Procedure::kFactory
   };
   intptr_t kind = static_cast<int>(procedure_kind);
-  if (kind == Procedure::kIncompleteProcedure) {
-    return RawFunction::kSignatureFunction;
-  } else {
-    ASSERT(0 <= kind && kind <= Procedure::kFactory);
-    return static_cast<RawFunction::Kind>(lookuptable[kind]);
-  }
+  ASSERT(0 <= kind && kind <= ProcedureHelper::kFactory);
+  return static_cast<RawFunction::Kind>(lookuptable[kind]);
 }
 
 bool KernelReader::FieldHasFunctionLiteralInitializer(const dart::Field& field,
                                                       TokenPosition* start,
                                                       TokenPosition* end) {
   dart::Zone* zone = Thread::Current()->zone();
   const Script& script = Script::Handle(zone, field.Script());
 
   TranslationHelper translation_helper(
       Thread::Current(), script.kernel_string_offsets(),
@@ skipping 30 matching lines @@
   initializer_fun.set_result_type(AbstractType::Handle(zone, field.type()));
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)