clang-format runtime/vm

runtime/vm/parser.h

 // Copyright (c) 2012, 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_PARSER_H_
 #define RUNTIME_VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 18 matching lines @@
 class ScopeBuildingResult;
 
 }  // kernel
 
 class ArgumentsDescriptor;
 class Isolate;
 class LocalScope;
 class LocalVariable;
 struct RegExpCompileData;
 class SourceLabel;
-template <typename T> class GrowableArray;
+template <typename T>
+class GrowableArray;
 class Parser;
 
 struct CatchParamDesc;
 class ClassDesc;
 struct MemberDesc;
 struct ParamList;
 struct QualIdent;
 class TopLevel;
 class RecursionChecker;
 
@@ skipping 17 matching lines @@
     return (key1.Value() == key2.Value());
   }
   static bool IsMatch(const TokenPosition& key1, const Object& b) {
     const Smi& key2 = Smi::Cast(b);
     return (key1.value() == key2.Value());
   }
   static uword Hash(const Object& obj) {
     const Smi& key = Smi::Cast(obj);
     return HashValue(key.Value());
   }
-  static uword Hash(const TokenPosition& key) {
-    return HashValue(key.value());
-  }
+  static uword Hash(const TokenPosition& key) { return HashValue(key.value()); }
   // Used by CacheConstantValue if a new constant is added to the map.
   static RawObject* NewKey(const TokenPosition& key) {
     return Smi::New(key.value());
   }
 
  private:
-  static uword HashValue(intptr_t pos) {
-    return pos % (Smi::kMaxValue - 13);
-  }
+  static uword HashValue(intptr_t pos) { return pos % (Smi::kMaxValue - 13); }
 };
 typedef UnorderedHashMap<ConstMapKeyEqualsTraits> ConstantsMap;
 
 // The class ParsedFunction holds the result of parsing a function.
 class ParsedFunction : public ZoneAllocated {
  public:
   ParsedFunction(Thread* thread, const Function& function)
       : thread_(thread),
         function_(function),
         code_(Code::Handle(zone(), function.unoptimized_code())),
         node_sequence_(NULL),
         regexp_compile_data_(NULL),
         instantiator_(NULL),
         current_context_var_(NULL),
         expression_temp_var_(NULL),
         finally_return_temp_var_(NULL),
         deferred_prefixes_(new ZoneGrowableArray<const LibraryPrefix*>()),
         guarded_fields_(new ZoneGrowableArray<const Field*>()),
         default_parameter_values_(NULL),
         first_parameter_index_(0),
         first_stack_local_index_(0),
         num_copied_params_(0),
         num_stack_locals_(0),
         have_seen_await_expr_(false),
         kernel_scopes_(NULL) {
     ASSERT(function.IsZoneHandle());
     // Every function has a local variable for the current context.
-    LocalVariable* temp = new(zone()) LocalVariable(
-        function.token_pos(),
-        function.token_pos(),
-        Symbols::CurrentContextVar(),
-        Object::dynamic_type());
+    LocalVariable* temp = new (zone())
+        LocalVariable(function.token_pos(), function.token_pos(),
+                      Symbols::CurrentContextVar(), Object::dynamic_type());
     ASSERT(temp != NULL);
     current_context_var_ = temp;
   }
 
   const Function& function() const { return function_; }
   const Code& code() const { return code_; }
 
   SequenceNode* node_sequence() const { return node_sequence_; }
   void SetNodeSequence(SequenceNode* node_sequence);
 
@@ skipping 21 matching lines @@
 
   const Instance& DefaultParameterValueAt(intptr_t i) const {
     ASSERT(default_parameter_values_ != NULL);
     return *default_parameter_values_->At(i);
   }
 
   ZoneGrowableArray<const Instance*>* default_parameter_values() const {
     return default_parameter_values_;
   }
 
-  LocalVariable* current_context_var() const {
-    return current_context_var_;
-  }
+  LocalVariable* current_context_var() const { return current_context_var_; }
 
   LocalVariable* expression_temp_var() const {
     ASSERT(has_expression_temp_var());
     return expression_temp_var_;
   }
   void set_expression_temp_var(LocalVariable* value) {
     ASSERT(!has_expression_temp_var());
     expression_temp_var_ = value;
   }
-  bool has_expression_temp_var() const {
-    return expression_temp_var_ != NULL;
-  }
+  bool has_expression_temp_var() const { return expression_temp_var_ != NULL; }
 
   LocalVariable* finally_return_temp_var() const {
     ASSERT(has_finally_return_temp_var());
     return finally_return_temp_var_;
   }
   void set_finally_return_temp_var(LocalVariable* value) {
     ASSERT(!has_finally_return_temp_var());
     finally_return_temp_var_ = value;
   }
   bool has_finally_return_temp_var() const {
@@ skipping 11 matching lines @@
 
   ZoneGrowableArray<const Field*>* guarded_fields() const {
     return guarded_fields_;
   }
 
   int first_parameter_index() const { return first_parameter_index_; }
   int first_stack_local_index() const { return first_stack_local_index_; }
   int num_copied_params() const { return num_copied_params_; }
   int num_stack_locals() const { return num_stack_locals_; }
   int num_non_copied_params() const {
-    return (num_copied_params_ == 0)
-        ? function().num_fixed_parameters() : 0;
+    return (num_copied_params_ == 0) ? function().num_fixed_parameters() : 0;
   }
 
   void AllocateVariables();
   void AllocateIrregexpVariables(intptr_t num_stack_locals);
 
   void record_await() { have_seen_await_expr_ = true; }
   bool have_seen_await() const { return have_seen_await_expr_; }
 
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
@@ skipping 74 matching lines @@
   };
   static RawObject* ParseFunctionParameters(const Function& func);
 
  private:
   friend class EffectGraphVisitor;  // For BuildNoSuchMethodArguments.
 
   struct Block;
   class TryStack;
   class TokenPosScope;
 
-  Parser(const Script& script,
-         const Library& library,
-         TokenPosition token_pos);
+  Parser(const Script& script, const Library& library, TokenPosition token_pos);
   Parser(const Script& script,
          ParsedFunction* function,
          TokenPosition token_pos);
   ~Parser();
 
   // The function for which we will generate code.
   const Function& current_function() const;
 
   // The innermost function being parsed.
   const Function& innermost_function() const;
@@ skipping 21 matching lines @@
 
   // FunctionLevel is 0 when parsing code of current_function(), and denotes
   // the relative nesting level when parsing a nested function.
   int FunctionLevel() const;
 
   // The class being parsed.
   const Class& current_class() const;
   void set_current_class(const Class& value);
 
   // ParsedFunction accessor.
-  ParsedFunction* parsed_function() const {
-    return parsed_function_;
-  }
+  ParsedFunction* parsed_function() const { return parsed_function_; }
 
   const Script& script() const { return script_; }
   void SetScript(const Script& script, TokenPosition token_pos);
 
   const Library& library() const { return library_; }
   void set_library(const Library& value) const { library_ = value.raw(); }
 
   // Parsing a library or a regular source script.
   bool is_library_source() const {
     return (script_.kind() == RawScript::kScriptTag) ||
-        (script_.kind() == RawScript::kLibraryTag);
+           (script_.kind() == RawScript::kLibraryTag);
   }
 
   bool is_part_source() const {
     return script_.kind() == RawScript::kSourceTag;
   }
 
   // Parsing library patch script.
   bool is_patch_source() const {
     return script_.kind() == RawScript::kPatchTag;
   }
 
-  TokenPosition TokenPos() const {
-    return tokens_iterator_.CurrentPosition();
-  }
+  TokenPosition TokenPos() const { return tokens_iterator_.CurrentPosition(); }
   TokenPosition PrevTokenPos() const { return prev_token_pos_; }
 
   Token::Kind CurrentToken() {
     if (token_kind_ == Token::kILLEGAL) {
       ComputeCurrentToken();
     }
     return token_kind_;
   }
 
   void ComputeCurrentToken();
@@ skipping 60 matching lines @@
                                          const TypeArguments& type_arguments);
 
   // Report error if parsed code is too deeply nested; avoid stack overflow.
   void CheckStack();
 
   // Report already formatted error.
   static void ReportError(const Error& error);
 
   // Concatenate and report an already formatted error and a new error message.
   static void ReportErrors(const Error& prev_error,
-                           const Script& script, TokenPosition token_pos,
-                           const char* format, ...) PRINTF_ATTRIBUTE(4, 5);
+                           const Script& script,
+                           TokenPosition token_pos,
+                           const char* format,
+                           ...) PRINTF_ATTRIBUTE(4, 5);
 
   // Report error message at location of current token in current script.
   void ReportError(const char* msg, ...) const PRINTF_ATTRIBUTE(2, 3);
 
   void ReportErrorBefore(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
 
   // Report error message at given location in current script.
-  void ReportError(TokenPosition token_pos,
-                   const char* msg, ...) const PRINTF_ATTRIBUTE(3, 4);
+  void ReportError(TokenPosition token_pos, const char* msg, ...) const
+      PRINTF_ATTRIBUTE(3, 4);
 
   // Report warning message at location of current token in current script.
   void ReportWarning(const char* msg, ...) const PRINTF_ATTRIBUTE(2, 3);
 
   // Report warning message at given location in current script.
-  void ReportWarning(TokenPosition token_pos,
-                     const char* msg, ...) const PRINTF_ATTRIBUTE(3, 4);
+  void ReportWarning(TokenPosition token_pos, const char* msg, ...) const
+      PRINTF_ATTRIBUTE(3, 4);
 
   void CheckRecursiveInvocation();
 
   const Instance& EvaluateConstExpr(TokenPosition expr_pos, AstNode* expr);
   StaticGetterNode* RunStaticFieldInitializer(const Field& field,
                                               TokenPosition field_ref_pos);
   RawObject* EvaluateConstConstructorCall(const Class& type_class,
                                           const TypeArguments& type_arguments,
                                           const Function& constructor,
                                           ArgumentListNode* arguments);
   LiteralNode* FoldConstExpr(TokenPosition expr_pos, AstNode* expr);
 
   // Support for parsing of scripts.
   void ParseTopLevel();
   void ParseEnumDeclaration(const GrowableObjectArray& pending_classes,
                             const Object& tl_owner,
                             TokenPosition metadata_pos);
   void ParseEnumDefinition(const Class& cls);
   void ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                              const Object& tl_owner,
                              TokenPosition metadata_pos);
   void ParseClassDefinition(const Class& cls);
   void ParseMixinAppAlias(const GrowableObjectArray& pending_classes,
                           const Object& tl_owner,
                           TokenPosition metadata_pos);
   void ParseTypedef(const GrowableObjectArray& pending_classes,
                     const Object& tl_owner,
                     TokenPosition metadata_pos);
   void ParseTopLevelVariable(TopLevel* top_level,
-                             const Object& owner, TokenPosition metadata_pos);
+                             const Object& owner,
+                             TokenPosition metadata_pos);
   void ParseTopLevelFunction(TopLevel* top_level,
-                             const Object& owner, TokenPosition metadata_pos);
+                             const Object& owner,
+                             TokenPosition metadata_pos);
   void ParseTopLevelAccessor(TopLevel* top_level,
-                             const Object& owner, TokenPosition metadata_pos);
+                             const Object& owner,
+                             TokenPosition metadata_pos);
   RawArray* EvaluateMetadata();
 
   RawFunction::AsyncModifier ParseFunctionModifier();
 
   // Support for parsing libraries.
   RawObject* CallLibraryTagHandler(Dart_LibraryTag tag,
                                    TokenPosition token_pos,
                                    const String& url);
   void ParseIdentList(GrowableObjectArray* names);
   void ParseLibraryDefinition(const Object& tl_owner);
   void ParseLibraryName();
   void ParseLibraryImportExport(const Object& tl_owner,
                                 TokenPosition metadata_pos);
   void ParseLibraryPart();
   void ParsePartHeader();
   void ParseLibraryNameObsoleteSyntax();
   void ParseLibraryImportObsoleteSyntax();
   void ParseLibraryIncludeObsoleteSyntax();
 
   void ResolveType(ClassFinalizer::FinalizationKind finalization,
                    AbstractType* type);
   RawAbstractType* ParseType(ClassFinalizer::FinalizationKind finalization,
                              bool allow_deferred_type = false,
                              bool consume_unresolved_prefix = true);
-  RawAbstractType* ParseType(
-      ClassFinalizer::FinalizationKind finalization,
-      bool allow_deferred_type,
-      bool consume_unresolved_prefix,
-      LibraryPrefix* prefix);
+  RawAbstractType* ParseType(ClassFinalizer::FinalizationKind finalization,
+                             bool allow_deferred_type,
+                             bool consume_unresolved_prefix,
+                             LibraryPrefix* prefix);
 
   void ParseTypeParameters(bool parameterizing_class);
   RawTypeArguments* ParseTypeArguments(
       ClassFinalizer::FinalizationKind finalization);
   void ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method);
   void ParseFieldDefinition(ClassDesc* members, MemberDesc* field);
   void CheckMemberNameConflict(ClassDesc* members, MemberDesc* member);
   void ParseClassMemberDefinition(ClassDesc* members,
                                   TokenPosition metadata_pos);
   void ParseFormalParameter(bool allow_explicit_default_value,
                             bool evaluate_metadata,
                             ParamList* params);
   void ParseFormalParameters(bool allow_explicit_default_values,
                              bool evaluate_metadata,
                              ParamList* params);
   void ParseFormalParameterList(bool allow_explicit_default_values,
                                 bool evaluate_metadata,
                                 ParamList* params);
   void CheckFieldsInitialized(const Class& cls);
   void AddImplicitConstructor(const Class& cls);
   void CheckConstructors(ClassDesc* members);
   AstNode* ParseExternalInitializedField(const Field& field);
   void ParseInitializedInstanceFields(
       const Class& cls,
       LocalVariable* receiver,
       GrowableArray<Field*>* initialized_fields);
-  AstNode* CheckDuplicateFieldInit(
-      TokenPosition init_pos,
-      GrowableArray<Field*>* initialized_fields,
-      AstNode* instance,
-      Field* field,
-      AstNode* init_value);
+  AstNode* CheckDuplicateFieldInit(TokenPosition init_pos,
+                                   GrowableArray<Field*>* initialized_fields,
+                                   AstNode* instance,
+                                   Field* field,
+                                   AstNode* init_value);
   StaticCallNode* GenerateSuperConstructorCall(
       const Class& cls,
       TokenPosition supercall_pos,
       LocalVariable* receiver,
       ArgumentListNode* forwarding_args);
-  StaticCallNode* ParseSuperInitializer(
-      const Class& cls,
-      LocalVariable* receiver);
+  StaticCallNode* ParseSuperInitializer(const Class& cls,
+                                        LocalVariable* receiver);
   AstNode* ParseInitializer(const Class& cls,
                             LocalVariable* receiver,
                             GrowableArray<Field*>* initialized_fields);
   void ParseConstructorRedirection(const Class& cls, LocalVariable* receiver);
   void ParseInitializers(const Class& cls,
                          LocalVariable* receiver,
                          GrowableArray<Field*>* initialized_fields);
   String& ParseNativeDeclaration();
   void ParseInterfaceList(const Class& cls);
   RawAbstractType* ParseMixins(const AbstractType& super_type);
@@ skipping 69 matching lines @@
   void OpenAsyncGeneratorClosure();
   SequenceNode* CloseAsyncGeneratorClosure(SequenceNode* body);
 
   void OpenAsyncTryBlock();
   SequenceNode* CloseBlock();
   SequenceNode* CloseAsyncFunction(const Function& closure,
                                    SequenceNode* closure_node);
 
   SequenceNode* CloseAsyncClosure(SequenceNode* body);
   SequenceNode* CloseAsyncTryBlock(SequenceNode* try_block);
-  SequenceNode* CloseAsyncGeneratorTryBlock(SequenceNode *body);
+  SequenceNode* CloseAsyncGeneratorTryBlock(SequenceNode* body);
 
   void AddAsyncClosureParameters(ParamList* params);
   void AddContinuationVariables();
   void AddAsyncClosureVariables();
   void AddAsyncGeneratorVariables();
 
   LocalVariable* LookupReceiver(LocalScope* from_scope, bool test_only);
   LocalVariable* LookupTypeArgumentsParameter(LocalScope* from_scope,
                                               bool test_only);
   void CaptureInstantiator();
@@ skipping 50 matching lines @@
                                     bool is_async,
                                     LocalVariable* exception_var,
                                     LocalVariable* stack_trace_var,
                                     LocalVariable* rethrow_exception_var,
                                     LocalVariable* rethrow_stack_trace_var);
   // Push try block onto the stack of try blocks in scope.
   void PushTry(Block* try_block);
   // Pop the inner most try block from the stack.
   TryStack* PopTry();
   // Collect saved try context variables if await or yield is in try block.
-  void CheckAsyncOpInTryBlock(
-      LocalVariable** saved_try_ctx,
-      LocalVariable** async_saved_try_ctx,
-      LocalVariable** outer_saved_try_ctx,
-      LocalVariable** outer_async_saved_try_ctx) const;
+  void CheckAsyncOpInTryBlock(LocalVariable** saved_try_ctx,
+                              LocalVariable** async_saved_try_ctx,
+                              LocalVariable** outer_saved_try_ctx,
+                              LocalVariable** outer_async_saved_try_ctx) const;
   // Add specified node to try block list so that it can be patched with
   // inlined finally code if needed.
   void AddNodeForFinallyInlining(AstNode* node);
   void RemoveNodesForFinallyInlining(SourceLabel* label);
   // Add the inlined finally clause to the specified node.
   void AddFinallyClauseToNode(bool is_async,
                               AstNode* node,
                               InlinedFinallyNode* finally_clause);
   AstNode* ParseTryStatement(String* label_name);
   RawAbstractType* ParseConstFinalVarOrType(
@@ skipping 81 matching lines @@
                                      const String& field_name,
                                      TokenPosition ident_pos);
 
   LocalVariable* LookupLocalScope(const String& ident);
   void CheckInstanceFieldAccess(TokenPosition field_pos,
                                 const String& field_name);
   bool ParsingStaticMember() const;
   const AbstractType* ReceiverType(const Class& cls);
   bool IsInstantiatorRequired() const;
   bool ResolveIdentInLocalScope(TokenPosition ident_pos,
-                                const String &ident,
+                                const String& ident,
                                 AstNode** node,
                                 intptr_t* function_level);
   static const bool kResolveLocally = true;
   static const bool kResolveIncludingImports = false;
 
   // Resolve a primary identifier in the library or prefix scope and
   // generate the corresponding AstNode.
   AstNode* ResolveIdentInCurrentLibraryScope(TokenPosition ident_pos,
                                              const String& ident);
   AstNode* ResolveIdentInPrefixScope(TokenPosition ident_pos,
@@ skipping 63 matching lines @@
 
   RawInstance* TryCanonicalize(const Instance& instance,
                                TokenPosition token_pos);
   void CacheConstantValue(TokenPosition token_pos, const Instance& value);
   bool GetCachedConstant(TokenPosition token_pos, Instance* value);
 
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return isolate_; }
   Zone* zone() const { return thread_->zone(); }
 
-  Thread* thread_;  // Cached current thread.
+  Thread* thread_;    // Cached current thread.
   Isolate* isolate_;  // Cached current isolate.
 
   Script& script_;
   TokenStream::Iterator tokens_iterator_;
   Token::Kind token_kind_;  // Cached token kind for current token.
   TokenPosition prev_token_pos_;
   Block* current_block_;
 
   // is_top_level_ is true if parsing the "top level" of a compilation unit,
   // that is class definitions, function type aliases, global functions,
@@ skipping 51 matching lines @@
 
   intptr_t recursion_counter_;
   friend class RecursionChecker;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PARSER_H_