[runtime] Support Proxy setPrototypeOf trap

src/parsing/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PARSING_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 125 matching lines @@
 #undef ALLOW_ACCESSORS
 
   uintptr_t stack_limit() const { return stack_limit_; }
 
  protected:
   enum AllowRestrictedIdentifiers {
     kAllowRestrictedIdentifiers,
     kDontAllowRestrictedIdentifiers
   };
 
-  enum Mode {
-    PARSE_LAZILY,
-    PARSE_EAGERLY
-  };
+  enum Mode { PARSE_LAZILY, PARSE_EAGERLY };
 
   enum VariableDeclarationContext {
     kStatementListItem,
     kStatement,
     kForStatement
   };
 
   class Checkpoint;
   class ObjectLiteralCheckerBase;
 
@@ skipping 125 matching lines @@
 
    private:
     FunctionState* function_state_;
     int next_materialized_literal_index_;
     int expected_property_count_;
   };
 
   class ParsingModeScope BASE_EMBEDDED {
    public:
     ParsingModeScope(ParserBase* parser, Mode mode)
-        : parser_(parser),
-          old_mode_(parser->mode()) {
+        : parser_(parser), old_mode_(parser->mode()) {
       parser_->mode_ = mode;
     }
-    ~ParsingModeScope() {
-      parser_->mode_ = old_mode_;
-    }
+    ~ParsingModeScope() { parser_->mode_ = old_mode_; }
 
    private:
     ParserBase* parser_;
     Mode old_mode_;
   };
 
   Scope* NewScope(Scope* parent, ScopeType scope_type) {
     // Must always pass the function kind for FUNCTION_SCOPE.
     DCHECK(scope_type != FUNCTION_SCOPE);
     return NewScope(parent, scope_type, kNormalFunction);
@@ skipping 65 matching lines @@
   }
 
   void ExpectSemicolon(bool* ok) {
     // Check for automatic semicolon insertion according to
     // the rules given in ECMA-262, section 7.9, page 21.
     Token::Value tok = peek();
     if (tok == Token::SEMICOLON) {
       Next();
       return;
     }
-    if (scanner()->HasAnyLineTerminatorBeforeNext() ||
-        tok == Token::RBRACE ||
+    if (scanner()->HasAnyLineTerminatorBeforeNext() || tok == Token::RBRACE ||
         tok == Token::EOS) {
       return;
     }
     Expect(Token::SEMICOLON, ok);
   }
 
   bool peek_any_identifier() {
     Token::Value next = peek();
     return next == Token::IDENTIFIER || next == Token::FUTURE_RESERVED_WORD ||
            next == Token::FUTURE_STRICT_RESERVED_WORD || next == Token::LET ||
@@ skipping 354 matching lines @@
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression, int beg_pos, int end_pos,
       MessageTemplate::Template message, bool* ok);
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression, int beg_pos, int end_pos,
       MessageTemplate::Template message, ParseErrorType type, bool* ok);
 
   // Used to validate property names in object literals and class literals
-  enum PropertyKind {
-    kAccessorProperty,
-    kValueProperty,
-    kMethodProperty
-  };
+  enum PropertyKind { kAccessorProperty, kValueProperty, kMethodProperty };
 
   class ObjectLiteralCheckerBase {
    public:
     explicit ObjectLiteralCheckerBase(ParserBase* parser) : parser_(parser) {}
 
     virtual void CheckProperty(Token::Value property, PropertyKind type,
                                bool is_static, bool is_generator, bool* ok) = 0;
 
     virtual ~ObjectLiteralCheckerBase() {}
 
@@ skipping 378 matching lines @@
 // The pre-parser doesn't need to build lists of expressions, identifiers, or
 // the like.
 template <typename T>
 class PreParserList {
  public:
   // These functions make list->Add(some_expression) work (and do nothing).
   PreParserList() : length_(0) {}
   PreParserList* operator->() { return this; }
   void Add(T, void*) { ++length_; }
   int length() const { return length_; }
+
  private:
   int length_;
 };
 
 
 typedef PreParserList<PreParserExpression> PreParserExpressionList;
 
 
 class PreParserStatement {
  public:
@@ skipping 19 matching lines @@
     }
     if (expression.IsUseStrongLiteral()) {
       return PreParserStatement(kUseStrongExpressionStatement);
     }
     if (expression.IsStringLiteral()) {
       return PreParserStatement(kStringLiteralExpressionStatement);
     }
     return Default();
   }
 
-  bool IsStringLiteral() {
-    return code_ == kStringLiteralExpressionStatement;
-  }
+  bool IsStringLiteral() { return code_ == kStringLiteralExpressionStatement; }
 
-  bool IsUseStrictLiteral() {
-    return code_ == kUseStrictExpressionStatement;
-  }
+  bool IsUseStrictLiteral() { return code_ == kUseStrictExpressionStatement; }
 
   bool IsUseStrongLiteral() { return code_ == kUseStrongExpressionStatement; }
 
-  bool IsFunctionDeclaration() {
-    return code_ == kFunctionDeclaration;
-  }
+  bool IsFunctionDeclaration() { return code_ == kFunctionDeclaration; }
 
-  bool IsJumpStatement() {
-    return code_ == kJumpStatement;
-  }
+  bool IsJumpStatement() { return code_ == kJumpStatement; }
 
  private:
   enum Type {
     kUnknownStatement,
     kJumpStatement,
     kStringLiteralExpressionStatement,
     kUseStrictExpressionStatement,
     kUseStrongExpressionStatement,
     kFunctionDeclaration
   };
 
   explicit PreParserStatement(Type code) : code_(code) {}
   Type code_;
 };
 
 
 typedef PreParserList<PreParserStatement> PreParserStatementList;
 
 
 class PreParserFactory {
  public:
   explicit PreParserFactory(void* unused_value_factory) {}
   PreParserExpression NewStringLiteral(PreParserIdentifier identifier,
                                        int pos) {
     return PreParserExpression::Default();
   }
-  PreParserExpression NewNumberLiteral(double number,
-                                       int pos) {
+  PreParserExpression NewNumberLiteral(double number, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewRegExpLiteral(PreParserIdentifier js_pattern,
                                        int js_flags, int literal_index,
                                        bool is_strong, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewArrayLiteral(PreParserExpressionList values,
-                                      int literal_index,
-                                      bool is_strong,
+                                      int literal_index, bool is_strong,
                                       int pos) {
     return PreParserExpression::ArrayLiteral();
   }
   PreParserExpression NewArrayLiteral(PreParserExpressionList values,
                                       int first_spread_index, int literal_index,
                                       bool is_strong, int pos) {
     return PreParserExpression::ArrayLiteral();
   }
   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
                                                PreParserExpression value,
                                                ObjectLiteralProperty::Kind kind,
                                                bool is_static,
                                                bool is_computed_name) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
                                                PreParserExpression value,
                                                bool is_static,
                                                bool is_computed_name) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewObjectLiteral(PreParserExpressionList properties,
                                        int literal_index,
                                        int boilerplate_properties,
-                                       bool has_function,
-                                       bool is_strong,
+                                       bool has_function, bool is_strong,
                                        int pos) {
     return PreParserExpression::ObjectLiteral();
   }
   PreParserExpression NewVariableProxy(void* variable) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewProperty(PreParserExpression obj,
-                                  PreParserExpression key,
-                                  int pos) {
+                                  PreParserExpression key, int pos) {
     if (obj.IsThis()) {
       return PreParserExpression::ThisProperty();
     }
     return PreParserExpression::Property();
   }
   PreParserExpression NewUnaryOperation(Token::Value op,
                                         PreParserExpression expression,
                                         int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewBinaryOperation(Token::Value op,
                                          PreParserExpression left,
                                          PreParserExpression right, int pos) {
     return PreParserExpression::BinaryOperation(left, op, right);
   }
   PreParserExpression NewCompareOperation(Token::Value op,
                                           PreParserExpression left,
                                           PreParserExpression right, int pos) {
     return PreParserExpression::Default();
   }
-  PreParserExpression NewAssignment(Token::Value op,
-                                    PreParserExpression left,
-                                    PreParserExpression right,
-                                    int pos) {
+  PreParserExpression NewAssignment(Token::Value op, PreParserExpression left,
+                                    PreParserExpression right, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewYield(PreParserExpression generator_object,
                                PreParserExpression expression,
-                               Yield::Kind yield_kind,
-                               int pos) {
+                               Yield::Kind yield_kind, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewConditional(PreParserExpression condition,
                                      PreParserExpression then_expression,
                                      PreParserExpression else_expression,
                                      int pos) {
     return PreParserExpression::Default();
   }
-  PreParserExpression NewCountOperation(Token::Value op,
-                                        bool is_prefix,
+  PreParserExpression NewCountOperation(Token::Value op, bool is_prefix,
                                         PreParserExpression expression,
                                         int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewCall(PreParserExpression expression,
-                              PreParserExpressionList arguments,
-                              int pos) {
+                              PreParserExpressionList arguments, int pos) {
     return PreParserExpression::Call();
   }
   PreParserExpression NewCallNew(PreParserExpression expression,
-                                 PreParserExpressionList arguments,
-                                 int pos) {
+                                 PreParserExpressionList arguments, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewCallRuntime(const AstRawString* name,
                                      const Runtime::Function* function,
                                      PreParserExpressionList arguments,
                                      int pos) {
     return PreParserExpression::Default();
   }
   PreParserStatement NewReturnStatement(PreParserExpression expression,
                                         int pos) {
@@ skipping 163 matching lines @@
 
   static PreParserExpression MarkExpressionAsAssigned(
       PreParserExpression expression) {
     // TODO(marja): To be able to produce the same errors, the preparser needs
     // to start tracking which expressions are variables and which are assigned.
     return expression;
   }
 
   bool ShortcutNumericLiteralBinaryExpression(PreParserExpression* x,
                                               PreParserExpression y,
-                                              Token::Value op,
-                                              int pos,
+                                              Token::Value op, int pos,
                                               PreParserFactory* factory) {
     return false;
   }
 
   PreParserExpression BuildUnaryExpression(PreParserExpression expression,
                                            Token::Value op, int pos,
                                            PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
@@ skipping 79 matching lines @@
                                                  PreParserFactory* factory,
                                                  int pos) {
     return PreParserExpression::Default();
   }
 
   static PreParserExpression DefaultConstructor(bool call_super, Scope* scope,
                                                 int pos, int end_pos) {
     return PreParserExpression::Default();
   }
 
-  static PreParserExpression ExpressionFromLiteral(
-      Token::Value token, int pos, Scanner* scanner,
-      PreParserFactory* factory) {
+  static PreParserExpression ExpressionFromLiteral(Token::Value token, int pos,
+                                                   Scanner* scanner,
+                                                   PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   static PreParserExpression ExpressionFromIdentifier(
       PreParserIdentifier name, int start_position, int end_position,
       Scope* scope, PreParserFactory* factory) {
     return PreParserExpression::FromIdentifier(name);
   }
 
-  PreParserExpression ExpressionFromString(int pos,
-                                           Scanner* scanner,
+  PreParserExpression ExpressionFromString(int pos, Scanner* scanner,
                                            PreParserFactory* factory = NULL);
 
   PreParserExpression GetIterator(PreParserExpression iterable,
                                   PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   static PreParserExpressionList NewExpressionList(int size, Zone* zone) {
     return PreParserExpressionList();
   }
 
   static PreParserStatementList NewStatementList(int size, Zone* zone) {
     return PreParserStatementList();
   }
 
   static PreParserExpressionList NewPropertyList(int size, Zone* zone) {
     return PreParserExpressionList();
   }
 
   static void AddParameterInitializationBlock(
-      const PreParserFormalParameters& parameters,
-      PreParserStatementList list, bool* ok) {}
+      const PreParserFormalParameters& parameters, PreParserStatementList list,
+      bool* ok) {}
 
   V8_INLINE void SkipLazyFunctionBody(int* materialized_literal_count,
                                       int* expected_property_count, bool* ok) {
     UNREACHABLE();
   }
 
   V8_INLINE PreParserStatementList ParseEagerFunctionBody(
       PreParserIdentifier function_name, int pos,
       const PreParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
 
   V8_INLINE void ParseArrowFunctionFormalParameterList(
-      PreParserFormalParameters* parameters,
-      PreParserExpression expression, const Scanner::Location& params_loc,
-      Scanner::Location* duplicate_loc, bool* ok);
+      PreParserFormalParameters* parameters, PreParserExpression expression,
+      const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
+      bool* ok);
 
   void ReindexLiterals(const PreParserFormalParameters& paramaters) {}
 
   struct TemplateLiteralState {};
 
   TemplateLiteralState OpenTemplateLiteral(int pos) {
     return TemplateLiteralState();
   }
   void AddTemplateSpan(TemplateLiteralState*, bool) {}
   void AddTemplateExpression(TemplateLiteralState*, PreParserExpression) {}
@@ skipping 73 matching lines @@
 // to speed up later parsing. Finding errors is not the goal of pre-parsing,
 // rather it is to speed up properly written and correct programs.
 // That means that contextual checks (like a label being declared where
 // it is used) are generally omitted.
 class PreParser : public ParserBase<PreParserTraits> {
  public:
   typedef PreParserIdentifier Identifier;
   typedef PreParserExpression Expression;
   typedef PreParserStatement Statement;
 
-  enum PreParseResult {
-    kPreParseStackOverflow,
-    kPreParseSuccess
-  };
+  enum PreParseResult { kPreParseStackOverflow, kPreParseSuccess };
 
   PreParser(Zone* zone, Scanner* scanner, AstValueFactory* ast_value_factory,
             ParserRecorder* log, uintptr_t stack_limit)
       : ParserBase<PreParserTraits>(zone, scanner, stack_limit, NULL,
                                     ast_value_factory, log, this) {}
 
   // Pre-parse the program from the character stream; returns true on
   // success (even if parsing failed, the pre-parse data successfully
   // captured the syntax error), and false if a stack-overflow happened
   // during parsing.
@@ skipping 121 matching lines @@
 }
 
 PreParserExpression PreParserTraits::SpreadCallNew(PreParserExpression function,
                                                    PreParserExpressionList args,
                                                    int pos) {
   return pre_parser_->factory()->NewCallNew(function, args, pos);
 }
 
 
 void PreParserTraits::ParseArrowFunctionFormalParameterList(
-    PreParserFormalParameters* parameters,
-    PreParserExpression params, const Scanner::Location& params_loc,
-    Scanner::Location* duplicate_loc, bool* ok) {
+    PreParserFormalParameters* parameters, PreParserExpression params,
+    const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
+    bool* ok) {
   // TODO(wingo): Detect duplicated identifiers in paramlists.  Detect parameter
   // lists that are too long.
 
   // Accomodate array literal for rest parameter.
   if (params.IsArrowFunctionFormalParametersWithRestParameter()) {
     ++parameters->materialized_literals_count;
     pre_parser_->function_state_->NextMaterializedLiteralIndex();
   }
 }
 
@@ skipping 260 matching lines @@
   }
 
   IdentifierT name = this->GetSymbol(scanner());
   if (this->IsArguments(name)) scope_->RecordArgumentsUsage();
   return name;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::IdentifierT
-ParserBase<Traits>::ParseIdentifierNameOrGetOrSet(bool* is_get,
-                                                  bool* is_set,
+ParserBase<Traits>::ParseIdentifierNameOrGetOrSet(bool* is_get, bool* is_set,
                                                   bool* ok) {
   IdentifierT result = ParseIdentifierName(ok);
   if (!*ok) return Traits::EmptyIdentifier();
   scanner()->IsGetOrSet(is_get, is_set);
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseRegExpLiteral(
@@ skipping 16 matching lines @@
     *ok = false;
     return Traits::EmptyExpression();
   }
   int js_flags = flags.FromJust();
   Next();
   return factory()->NewRegExpLiteral(js_pattern, js_flags, literal_index,
                                      is_strong(language_mode()), pos);
 }
 
 
-#define CHECK_OK  ok); \
+#define CHECK_OK  ok);                      \
   if (!*ok) return this->EmptyExpression(); \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 // Used in functions where the return type is not ExpressionT.
 #define CHECK_OK_CUSTOM(x) ok); \
-  if (!*ok) return this->x(); \
+  if (!*ok) return this->x();   \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParsePrimaryExpression(ExpressionClassifier* classifier,
                                            bool* ok) {
   // PrimaryExpression ::
@@ skipping 614 matching lines @@
     if (fni_ != nullptr) {
       fni_->Infer();
       fni_->Leave();
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
 
   // Computation of literal_index must happen before pre parse bailout.
   int literal_index = function_state_->NextMaterializedLiteralIndex();
 
-  return factory()->NewObjectLiteral(properties,
-                                     literal_index,
-                                     number_of_boilerplate_properties,
-                                     has_function,
-                                     is_strong(language_mode()),
-                                     pos);
+  return factory()->NewObjectLiteral(
+      properties, literal_index, number_of_boilerplate_properties, has_function,
+      is_strong(language_mode()), pos);
 }
 
 
 template <class Traits>
 typename Traits::Type::ExpressionList ParserBase<Traits>::ParseArguments(
     Scanner::Location* first_spread_arg_loc, ExpressionClassifier* classifier,
     bool* ok) {
   // Arguments ::
   //   '(' (AssignmentExpression)*[','] ')'
 
@@ skipping 200 matching lines @@
       case Token::SEMICOLON:
       case Token::RBRACE:
       case Token::RBRACK:
       case Token::RPAREN:
       case Token::COLON:
       case Token::COMMA:
         // The above set of tokens is the complete set of tokens that can appear
         // after an AssignmentExpression, and none of them can start an
         // AssignmentExpression.  This allows us to avoid looking for an RHS for
         // a Yield::kSuspend operation, given only one look-ahead token.
-        if (kind == Yield::kSuspend)
-          break;
+        if (kind == Yield::kSuspend) break;
         DCHECK_EQ(Yield::kDelegating, kind);
-        // Delegating yields require an RHS; fall through.
+      // Delegating yields require an RHS; fall through.
       default:
         expression = ParseAssignmentExpression(false, classifier, CHECK_OK);
         break;
     }
   }
   if (kind == Yield::kDelegating) {
     // var iterator = subject[Symbol.iterator]();
     expression = this->GetIterator(expression, factory());
   }
   typename Traits::Type::YieldExpression yield =
@@ skipping 55 matching lines @@
         continue;
       }
 
       // For now we distinguish between comparisons and other binary
       // operations.  (We could combine the two and get rid of this
       // code and AST node eventually.)
       if (Token::IsCompareOp(op)) {
         // We have a comparison.
         Token::Value cmp = op;
         switch (op) {
-          case Token::NE: cmp = Token::EQ; break;
-          case Token::NE_STRICT: cmp = Token::EQ_STRICT; break;
-          default: break;
+          case Token::NE:
+            cmp = Token::EQ;
+            break;
+          case Token::NE_STRICT:
+            cmp = Token::EQ_STRICT;
+            break;
+          default:
+            break;
         }
         if (cmp == Token::EQ && is_strong(language_mode())) {
           ReportMessageAt(op_location, MessageTemplate::kStrongEqual);
           *ok = false;
           return this->EmptyExpression();
         }
         x = factory()->NewCompareOperation(cmp, x, y, pos);
         if (cmp != op) {
           // The comparison was negated - add a NOT.
           x = factory()->NewUnaryOperation(Token::NOT, x, pos);
@@ skipping 53 matching lines @@
     BindingPatternUnexpectedToken(classifier);
     ArrowFormalParametersUnexpectedToken(classifier);
     op = Next();
     int beg_pos = peek_position();
     ExpressionT expression = this->ParseUnaryExpression(classifier, CHECK_OK);
     expression = this->CheckAndRewriteReferenceExpression(
         expression, beg_pos, scanner()->location().end_pos,
         MessageTemplate::kInvalidLhsInPrefixOp, CHECK_OK);
     this->MarkExpressionAsAssigned(expression);
 
-    return factory()->NewCountOperation(op,
-                                        true /* prefix */,
-                                        expression,
+    return factory()->NewCountOperation(op, true /* prefix */, expression,
                                         position());
 
   } else {
     return this->ParsePostfixExpression(classifier, ok);
   }
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParsePostfixExpression(ExpressionClassifier* classifier,
                                            bool* ok) {
   // PostfixExpression ::
   //   LeftHandSideExpression ('++' | '--')?
 
   int lhs_beg_pos = peek_position();
   ExpressionT expression =
       this->ParseLeftHandSideExpression(classifier, CHECK_OK);
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       Token::IsCountOp(peek())) {
     BindingPatternUnexpectedToken(classifier);
     ArrowFormalParametersUnexpectedToken(classifier);
 
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_beg_pos, scanner()->location().end_pos,
         MessageTemplate::kInvalidLhsInPostfixOp, CHECK_OK);
     expression = this->MarkExpressionAsAssigned(expression);
 
     Token::Value next = Next();
-    expression =
-        factory()->NewCountOperation(next,
-                                     false /* postfix */,
-                                     expression,
-                                     position());
+    expression = factory()->NewCountOperation(next, false /* postfix */,
+                                              expression, position());
   }
   return expression;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseLeftHandSideExpression(
     ExpressionClassifier* classifier, bool* ok) {
   // LeftHandSideExpression ::
@@ skipping 477 matching lines @@
       default:
         return expression;
     }
   }
   DCHECK(false);
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
-void ParserBase<Traits>::ParseFormalParameter(
-    FormalParametersT* parameters, ExpressionClassifier* classifier, bool* ok) {
+void ParserBase<Traits>::ParseFormalParameter(FormalParametersT* parameters,
+                                              ExpressionClassifier* classifier,
+                                              bool* ok) {
   // FormalParameter[Yield,GeneratorParameter] :
   //   BindingElement[?Yield, ?GeneratorParameter]
   bool is_rest = parameters->has_rest;
 
   Token::Value next = peek();
   ExpressionT pattern = ParsePrimaryExpression(classifier, ok);
   if (!*ok) return;
 
   ValidateBindingPattern(classifier, ok);
   if (!*ok) return;
@@ skipping 63 matching lines @@
           allow_harmony_rest_parameters() && Check(Token::ELLIPSIS);
       ParseFormalParameter(parameters, classifier, ok);
       if (!*ok) return;
     } while (!parameters->has_rest && Check(Token::COMMA));
 
     if (parameters->has_rest) {
       parameters->is_simple = false;
       classifier->RecordNonSimpleParameter();
       if (peek() == Token::COMMA) {
         ReportMessageAt(scanner()->peek_location(),
-                      MessageTemplate::kParamAfterRest);
+                        MessageTemplate::kParamAfterRest);
         *ok = false;
         return;
       }
     }
   }
 
   for (int i = 0; i < parameters->Arity(); ++i) {
     auto parameter = parameters->at(i);
     Traits::DeclareFormalParameter(parameters->scope, parameter, classifier);
   }
@@ skipping 358 matching lines @@
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H