[runtime] Support Proxy setPrototypeOf trap

src/parsing/preparser.cc

 // Copyright 2011 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.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 21 matching lines @@
                                       MessageTemplate::Template message,
                                       const char* arg,
                                       ParseErrorType error_type) {
   pre_parser_->log_->LogMessage(start_pos, end_pos, message, arg, error_type);
 }
 
 
 PreParserIdentifier PreParserTraits::GetSymbol(Scanner* scanner) {
   if (scanner->current_token() == Token::FUTURE_RESERVED_WORD) {
     return PreParserIdentifier::FutureReserved();
-  } else if (scanner->current_token() ==
-             Token::FUTURE_STRICT_RESERVED_WORD) {
+  } else if (scanner->current_token() == Token::FUTURE_STRICT_RESERVED_WORD) {
     return PreParserIdentifier::FutureStrictReserved();
   } else if (scanner->current_token() == Token::LET) {
     return PreParserIdentifier::Let();
   } else if (scanner->current_token() == Token::STATIC) {
     return PreParserIdentifier::Static();
   } else if (scanner->current_token() == Token::YIELD) {
     return PreParserIdentifier::Yield();
   }
   if (scanner->UnescapedLiteralMatches("eval", 4)) {
     return PreParserIdentifier::Eval();
@@ skipping 197 matching lines @@
 
     if (directive_prologue) {
       bool use_strict_found = statement.IsUseStrictLiteral();
       bool use_strong_found =
           statement.IsUseStrongLiteral() && allow_strong_mode();
 
       if (use_strict_found) {
         scope_->SetLanguageMode(
             static_cast<LanguageMode>(scope_->language_mode() | STRICT));
       } else if (use_strong_found) {
-        scope_->SetLanguageMode(static_cast<LanguageMode>(
-            scope_->language_mode() | STRONG));
+        scope_->SetLanguageMode(
+            static_cast<LanguageMode>(scope_->language_mode() | STRONG));
         if (IsClassConstructor(function_state_->kind())) {
           // "use strong" cannot occur in a class constructor body, to avoid
           // unintuitive strong class object semantics.
           PreParserTraits::ReportMessageAt(
               token_loc, MessageTemplate::kStrongConstructorDirective);
           *ok = false;
           return;
         }
       } else if (!statement.IsStringLiteral()) {
         directive_prologue = false;
@@ skipping 25 matching lines @@
         bookmark->Reset();
         return;
       }
       maybe_reset = false;
     }
   }
 }
 
 
 #define CHECK_OK  ok);                   \
-  if (!*ok) return Statement::Default();  \
+  if (!*ok) return Statement::Default(); \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
 PreParser::Statement PreParser::ParseStatement(bool* ok) {
   // Statement ::
   //   EmptyStatement
   //   ...
 
@@ skipping 117 matching lines @@
 PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   bool is_generator = Check(Token::MUL);
   bool is_strict_reserved = false;
-  Identifier name = ParseIdentifierOrStrictReservedWord(
-      &is_strict_reserved, CHECK_OK);
+  Identifier name =
+      ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
   ParseFunctionLiteral(name, scanner()->location(),
                        is_strict_reserved ? kFunctionNameIsStrictReserved
                                           : kFunctionNameValidityUnknown,
                        is_generator ? FunctionKind::kGeneratorFunction
                                     : FunctionKind::kNormalFunction,
                        pos, FunctionLiteral::DECLARATION,
                        FunctionLiteral::NORMAL_ARITY, language_mode(),
                        CHECK_OK);
   return Statement::FunctionDeclaration();
 }
@@ skipping 25 matching lines @@
   Statement final = Statement::Default();
   while (peek() != Token::RBRACE) {
     final = ParseStatementListItem(CHECK_OK);
   }
   Expect(Token::RBRACE, ok);
   return final;
 }
 
 
 PreParser::Statement PreParser::ParseVariableStatement(
-    VariableDeclarationContext var_context,
-    bool* ok) {
+    VariableDeclarationContext var_context, bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
   Statement result = ParseVariableDeclarations(
       var_context, nullptr, nullptr, nullptr, nullptr, nullptr, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return result;
 }
 
 
@@ skipping 135 matching lines @@
     case Token::FUNCTION:
     case Token::LBRACE:
       UNREACHABLE();  // Always handled by the callers.
     case Token::CLASS:
       ReportUnexpectedToken(Next());
       *ok = false;
       return Statement::Default();
 
     case Token::THIS:
       if (!FLAG_strong_this) break;
-      // Fall through.
+    // Fall through.
     case Token::SUPER:
       if (is_strong(language_mode()) &&
           IsClassConstructor(function_state_->kind())) {
         bool is_this = peek() == Token::THIS;
         Expression expr = Expression::Default();
         ExpressionClassifier classifier;
         if (is_this) {
           expr = ParseStrongInitializationExpression(&classifier, CHECK_OK);
         } else {
           expr = ParseStrongSuperCallExpression(&classifier, CHECK_OK);
@@ skipping 67 matching lines @@
   //   'if' '(' Expression ')' Statement ('else' Statement)?
 
   Expect(Token::IF, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   Statement stat = ParseSubStatement(CHECK_OK);
   if (peek() == Token::ELSE) {
     Next();
     Statement else_stat = ParseSubStatement(CHECK_OK);
-    stat = (stat.IsJumpStatement() && else_stat.IsJumpStatement()) ?
-        Statement::Jump() : Statement::Default();
+    stat = (stat.IsJumpStatement() && else_stat.IsJumpStatement())
+               ? Statement::Jump()
+               : Statement::Default();
   } else {
     stat = Statement::Default();
   }
   return stat;
 }
 
 
 PreParser::Statement PreParser::ParseContinueStatement(bool* ok) {
   // ContinueStatement ::
   //   'continue' [no line terminator] Identifier? ';'
 
   Expect(Token::CONTINUE, CHECK_OK);
   Token::Value tok = peek();
-  if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
-      tok != Token::SEMICOLON &&
-      tok != Token::RBRACE &&
-      tok != Token::EOS) {
+  if (!scanner()->HasAnyLineTerminatorBeforeNext() && tok != Token::SEMICOLON &&
+      tok != Token::RBRACE && tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::Jump();
 }
 
 
 PreParser::Statement PreParser::ParseBreakStatement(bool* ok) {
   // BreakStatement ::
   //   'break' [no line terminator] Identifier? ';'
 
   Expect(Token::BREAK, CHECK_OK);
   Token::Value tok = peek();
-  if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
-      tok != Token::SEMICOLON &&
-      tok != Token::RBRACE &&
-      tok != Token::EOS) {
+  if (!scanner()->HasAnyLineTerminatorBeforeNext() && tok != Token::SEMICOLON &&
+      tok != Token::RBRACE && tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::Jump();
 }
 
 
 PreParser::Statement PreParser::ParseReturnStatement(bool* ok) {
   // ReturnStatement ::
   //   'return' [no line terminator] Expression? ';'
 
   // Consume the return token. It is necessary to do before
   // reporting any errors on it, because of the way errors are
   // reported (underlining).
   Expect(Token::RETURN, CHECK_OK);
   function_state_->set_return_location(scanner()->location());
 
   // An ECMAScript program is considered syntactically incorrect if it
   // contains a return statement that is not within the body of a
   // function. See ECMA-262, section 12.9, page 67.
   // This is not handled during preparsing.
 
   Token::Value tok = peek();
-  if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
-      tok != Token::SEMICOLON &&
-      tok != Token::RBRACE &&
-      tok != Token::EOS) {
+  if (!scanner()->HasAnyLineTerminatorBeforeNext() && tok != Token::SEMICOLON &&
+      tok != Token::RBRACE && tok != Token::EOS) {
     if (is_strong(language_mode()) &&
         IsClassConstructor(function_state_->kind())) {
       int pos = peek_position();
       ReportMessageAt(Scanner::Location(pos, pos + 1),
                       MessageTemplate::kStrongConstructorReturnValue);
       *ok = false;
       return Statement::Default();
     }
     ParseExpression(true, CHECK_OK);
   }
@@ skipping 36 matching lines @@
   while (token != Token::RBRACE) {
     if (token == Token::CASE) {
       Expect(Token::CASE, CHECK_OK);
       ParseExpression(true, CHECK_OK);
     } else {
       Expect(Token::DEFAULT, CHECK_OK);
     }
     Expect(Token::COLON, CHECK_OK);
     token = peek();
     Statement statement = Statement::Jump();
-    while (token != Token::CASE &&
-           token != Token::DEFAULT &&
+    while (token != Token::CASE && token != Token::DEFAULT &&
            token != Token::RBRACE) {
       statement = ParseStatementListItem(CHECK_OK);
       token = peek();
     }
     if (is_strong(language_mode()) && !statement.IsJumpStatement() &&
         token != Token::RBRACE) {
       ReportMessageAt(scanner()->location(),
                       MessageTemplate::kStrongSwitchFallthrough);
       *ok = false;
       return Statement::Default();
@@ skipping 194 matching lines @@
   // DebuggerStatement ::
   //   'debugger' ';'
 
   Expect(Token::DEBUGGER, CHECK_OK);
   ExpectSemicolon(ok);
   return Statement::Default();
 }
 
 
 #undef CHECK_OK
-#define CHECK_OK  ok);                     \
-  if (!*ok) return Expression::Default();  \
+#define CHECK_OK  ok);                    \
+  if (!*ok) return Expression::Default(); \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
 PreParser::Expression PreParser::ParseFunctionLiteral(
     Identifier function_name, Scanner::Location function_name_location,
     FunctionNameValidity function_name_validity, FunctionKind kind,
     int function_token_pos, FunctionLiteral::FunctionType function_type,
     FunctionLiteral::ArityRestriction arity_restriction,
@@ skipping 12 matching lines @@
   ExpressionClassifier formals_classifier(&duplicate_finder);
 
   Expect(Token::LPAREN, CHECK_OK);
   int start_position = scanner()->location().beg_pos;
   function_scope->set_start_position(start_position);
   PreParserFormalParameters formals(function_scope);
   ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
   int formals_end_position = scanner()->location().end_pos;
 
-  CheckArityRestrictions(formals.arity, arity_restriction,
-                         formals.has_rest, start_position,
-                         formals_end_position, CHECK_OK);
+  CheckArityRestrictions(formals.arity, arity_restriction, formals.has_rest,
+                         start_position, formals_end_position, CHECK_OK);
 
   // See Parser::ParseFunctionLiteral for more information about lazy parsing
   // and lazy compilation.
   bool is_lazily_parsed =
       (outer_is_script_scope && allow_lazy() && !parenthesized_function_);
   parenthesized_function_ = false;
 
   Expect(Token::LBRACE, CHECK_OK);
   if (is_lazily_parsed) {
     ParseLazyFunctionLiteralBody(CHECK_OK);
@@ skipping 144 matching lines @@
     Expect(Token::RBRACE, CHECK_OK);
     return PreParserExpression::Default();
   }
 }
 
 #undef CHECK_OK
 
 
 }  // namespace internal
 }  // namespace v8