Remove some "namespace" classes from C++ Kernel

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)
@@ skipping 22 matching lines @@
       ASSERT(tag == kFunctionNode);
       if (++next_read_ == field) return;
     }
     case kPosition:
       position_ = builder_->ReadPosition();  // read position.
       if (++next_read_ == field) return;
     case kEndPosition:
       end_position_ = builder_->ReadPosition();  // read end position.
       if (++next_read_ == field) return;
     case kAsyncMarker:
-      async_marker_ = static_cast<FunctionNode::AsyncMarker>(
-          builder_->ReadByte());  // read async marker.
+      async_marker_ = static_cast<AsyncMarker>(builder_->ReadByte());
       if (++next_read_ == field) return;
     case kDartAsyncMarker:
-      dart_async_marker_ = static_cast<FunctionNode::AsyncMarker>(
+      dart_async_marker_ = static_cast<AsyncMarker>(
           builder_->ReadByte());  // read dart async marker.
       if (++next_read_ == field) return;
     case kTypeParameters:
       builder_->SkipTypeParametersList();  // read type parameters.
       if (++next_read_ == field) return;
     case kTotalParameterCount:
       total_parameter_count_ =
           builder_->ReadUInt();  // read total parameter count.
       if (++next_read_ == field) return;
     case kRequiredParameterCount:
@@ skipping 40 matching lines @@
       if (++next_read_ == field) return;
     case kInitializer:
       if (builder_->ReadTag() == kSomething)
         builder_->SkipExpression();  // read initializer.
       if (++next_read_ == field) return;
     case kEnd:
       return;
   }
 }
 
+FieldHelper::FieldHelper(StreamingFlowGraphBuilder* builder, intptr_t offset)
+    : builder_(builder),
+      next_read_(kStart),
+      has_function_literal_initializer_(false) {
+  builder_->SetOffset(offset);
+}
+
 void FieldHelper::ReadUntilExcluding(Field field,
                                      bool detect_function_literal_initializer) {
   if (field <= next_read_) return;
 
   // Ordered with fall-through.
   switch (next_read_) {
     case kStart: {
       Tag tag = builder_->ReadTag();  // read tag.
       ASSERT(tag == kField);
       if (++next_read_ == field) return;
@@ skipping 71 matching lines @@
       canonical_name_ =
           builder_->ReadCanonicalNameReference();  // read canonical_name.
       if (++next_read_ == field) return;
     case kPosition:
       position_ = builder_->ReadPosition(false);  // read position.
       if (++next_read_ == field) return;
     case kEndPosition:
       end_position_ = builder_->ReadPosition(false);  // read end position.
       if (++next_read_ == field) return;
     case kKind:
-      kind_ = static_cast<Procedure::ProcedureKind>(
-          builder_->ReadByte());  // read kind.
+      kind_ = static_cast<Kind>(builder_->ReadByte());
       if (++next_read_ == field) return;
     case kFlags:
       flags_ = builder_->ReadFlags();  // read flags.
       if (++next_read_ == field) return;
     case kName:
       builder_->SkipName();  // read name.
       if (++next_read_ == field) return;
     case kSourceUriIndex:
       source_uri_index_ = builder_->ReadUInt();  // read source_uri_index.
       builder_->current_script_id_ = source_uri_index_;
@@ skipping 589 matching lines @@
 
   intptr_t list_length =
       builder_->ReadListLength();  // read type_parameters list length.
   for (intptr_t i = 0; i < list_length; ++i) {
     builder_->SkipStringReference();  // read ith name index.
     VisitDartType();                  // read ith bound.
   }
   function_node_helper.SetJustRead(FunctionNodeHelper::kTypeParameters);
 
   if (FLAG_causal_async_stacks &&
-      (function_node_helper.dart_async_marker_ == FunctionNode::kAsync ||
-       function_node_helper.dart_async_marker_ == FunctionNode::kAsyncStar)) {
+      (function_node_helper.dart_async_marker_ == FunctionNodeHelper::kAsync ||
+       function_node_helper.dart_async_marker_ ==
+           FunctionNodeHelper::kAsyncStar)) {
     LocalVariable* asyncStackTraceVar = MakeVariable(
         TokenPosition::kNoSource, TokenPosition::kNoSource,
         Symbols::AsyncStackTraceVar(), AbstractType::dynamic_type());
     scope_->AddVariable(asyncStackTraceVar);
   }
 
-  if (function_node_helper.async_marker_ == FunctionNode::kSyncYielding) {
+  if (function_node_helper.async_marker_ == FunctionNodeHelper::kSyncYielding) {
     LocalScope* scope = parsed_function_->node_sequence()->scope();
     intptr_t offset = parsed_function_->function().num_fixed_parameters();
     for (intptr_t i = 0;
          i < parsed_function_->function().NumOptionalPositionalParameters();
          i++) {
       scope->VariableAt(offset + i)->set_is_forced_stack();
     }
   }
 
   // Read (but don't visit) the positional and named parameters, because they've
   // already been added to the scope.
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kBody);
 
   if (builder_->ReadTag() == kSomething) {
     PositionScope scope(builder_->reader_);
     VisitStatement();  // Read body
     first_body_token_position_ = builder_->reader_->min_position();
   }
 
   // Ensure that :await_jump_var, :await_ctx_var, :async_op and
   // :async_stack_trace are captured.
-  if (function_node_helper.async_marker_ == FunctionNode::kSyncYielding) {
+  if (function_node_helper.async_marker_ == FunctionNodeHelper::kSyncYielding) {
     {
       LocalVariable* temp = NULL;
       LookupCapturedVariableByName(
           (depth_.function_ == 0) ? &result_->yield_jump_variable : &temp,
           Symbols::AwaitJumpVar());
     }
     {
       LocalVariable* temp = NULL;
       LookupCapturedVariableByName(
           (depth_.function_ == 0) ? &result_->yield_context_variable : &temp,
@@ skipping 514 matching lines @@
       VisitStatement();  // read finalizer.
 
       --depth_.catch_;
       return;
     }
     case kYieldStatement: {
       builder_->ReadPosition();           // read position.
       word flags = builder_->ReadByte();  // read flags.
       builder_->SkipExpression();         // read expression.
 
-      ASSERT((flags & YieldStatement::kFlagNative) ==
-             YieldStatement::kFlagNative);
+      ASSERT(flags == kNativeYieldFlags);
       if (depth_.function_ == 0) {
         AddSwitchVariable();
         // Promote all currently visible local variables into the context.
         // TODO(27590) CaptureLocalVariables promotes to many variables into
         // the scope. Mark those variables as stack_local.
         // TODO(27590) we don't need to promote those variables that are
         // not used across yields.
         scope_->CaptureLocalVariables(current_function_scope_);
       }
       return;
@@ skipping 182 matching lines @@
 
 void StreamingScopeBuilder::HandleLocalFunction(intptr_t parent_kernel_offset) {
   // "Peek" ahead into the function node
   intptr_t offset = builder_->ReaderOffset();
 
   FunctionNodeHelper function_node_helper(builder_);
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kPositionalParameters);
 
   LocalScope* saved_function_scope = current_function_scope_;
-  FunctionNode::AsyncMarker saved_function_async_marker =
+  FunctionNodeHelper::AsyncMarker saved_function_async_marker =
       current_function_async_marker_;
-  StreamingScopeBuilder::DepthState saved_depth_state = depth_;
+  DepthState saved_depth_state = depth_;
   depth_ = DepthState(depth_.function_ + 1);
   EnterScope(relative_kernel_offset_ + parent_kernel_offset);
   current_function_scope_ = scope_;
   current_function_async_marker_ = function_node_helper.async_marker_;
   if (depth_.function_ == 1) {
     FunctionScope function_scope = {relative_kernel_offset_ + offset, scope_};
     result_->function_scopes.Add(function_scope);
   }
 
   // read positional_parameters and named_parameters.
@@ skipping 80 matching lines @@
   LocalVariable* v = NULL;
 
   // If we are inside a function with yield points then Kernel transformer
   // could have lifted some of the auxiliary exception variables into the
   // context to preserve them across yield points because they might
   // be needed for rethrow.
   // Check if it did and capture such variables instead of introducing
   // new local ones.
   // Note: function that wrap kSyncYielding function does not contain
   // its own try/catches.
-  if (current_function_async_marker_ == FunctionNode::kSyncYielding) {
+  if (current_function_async_marker_ == FunctionNodeHelper::kSyncYielding) {
     ASSERT(current_function_scope_->parent() != NULL);
     v = current_function_scope_->parent()->LocalLookupVariable(
         GenerateName(prefix, nesting_depth - 1));
     if (v != NULL) {
       scope_->CaptureVariable(v);
     }
   }
 
   // No need to create variables for try/catch-statements inside
   // nested functions.
@@ skipping 860 matching lines @@
     result_ = H.Canonicalize(*receiver);
   }
 }
 
 void StreamingConstantEvaluator::EvaluateNot() {
   result_ ^= Bool::Get(!EvaluateBooleanExpressionHere()).raw();
 }
 
 void StreamingConstantEvaluator::EvaluateLogicalExpression() {
   bool left = EvaluateBooleanExpressionHere();  // read left.
-  LogicalExpression::Operator op = static_cast<LogicalExpression::Operator>(
-      builder_->ReadByte());  // read operator.
-  if (op == LogicalExpression::kAnd) {
+  LogicalOperator op = static_cast<LogicalOperator>(builder_->ReadByte());
+  if (op == kAnd) {
     if (left) {
       EvaluateBooleanExpressionHere();  // read right.
     } else {
       builder_->SkipExpression();  // read right.
     }
   } else {
-    ASSERT(op == LogicalExpression::kOr);
+    ASSERT(op == kOr);
     if (!left) {
       EvaluateBooleanExpressionHere();  // read right.
     } else {
       builder_->SkipExpression();  // read right.
     }
   }
 }
 
 void StreamingConstantEvaluator::EvaluateConditionalExpression() {
   bool condition = EvaluateBooleanExpressionHere();
@@ skipping 3219 matching lines @@
 
 Fragment StreamingFlowGraphBuilder::BuildLogicalExpression(
     TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   bool negate;
   Fragment instructions = TranslateCondition(&negate);  // read left.
 
   TargetEntryInstr* right_entry;
   TargetEntryInstr* constant_entry;
-  LogicalExpression::Operator op =
-      static_cast<LogicalExpression::Operator>(ReadByte());
+  LogicalOperator op = static_cast<LogicalOperator>(ReadByte());
 
-  if (op == LogicalExpression::kAnd) {
+  if (op == kAnd) {
     instructions += BranchIfTrue(&right_entry, &constant_entry, negate);
   } else {
     instructions += BranchIfTrue(&constant_entry, &right_entry, negate);
   }
 
   Value* top = stack();
   Fragment right_fragment(right_entry);
   right_fragment += TranslateCondition(&negate);  // read right.
 
   right_fragment += Constant(Bool::True());
   right_fragment +=
       StrictCompare(negate ? Token::kNE_STRICT : Token::kEQ_STRICT);
   right_fragment += StoreLocal(TokenPosition::kNoSource,
                                parsed_function()->expression_temp_var());
   right_fragment += Drop();
 
   ASSERT(top == stack());
   Fragment constant_fragment(constant_entry);
-  constant_fragment += Constant(Bool::Get(op == LogicalExpression::kOr));
+  constant_fragment += Constant(Bool::Get(op == kOr));
   constant_fragment += StoreLocal(TokenPosition::kNoSource,
                                   parsed_function()->expression_temp_var());
   constant_fragment += Drop();
 
   JoinEntryInstr* join = BuildJoinEntry();
   right_fragment += Goto(join);
   constant_fragment += Goto(join);
 
   return Fragment(instructions.entry, join) +
          LoadLocal(parsed_function()->expression_temp_var());
@@ skipping 1362 matching lines @@
   }
   catch_depth_dec();
 
   return Fragment(try_body.entry, after_try);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildYieldStatement() {
   TokenPosition position = ReadPosition();  // read position.
   uint8_t flags = ReadByte();               // read flags.
 
-  ASSERT((flags & YieldStatement::kFlagNative) ==
-         YieldStatement::kFlagNative);  // Must have been desugared.
+  ASSERT(flags == kNativeYieldFlags);  // Must have been desugared.
 
   // Setup yield/continue point:
   //
   //   ...
   //   :await_jump_var = index;
   //   :await_ctx_var = :current_context_var
   //   return <expr>
   //
   // Continuation<index>:
   //   Drop(1)
@@ skipping 152 matching lines @@
       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_ ==
-                                 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;
       }
       function.set_is_generated_body(function_node_helper.async_marker_ ==
-                                     FunctionNode::kSyncYielding);
+                                     FunctionNodeHelper::kSyncYielding);
       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);
@@ skipping 358 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)