Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1)

Side by Side Diff: src/parsing/preparser.cc

Issue 2160593002: Introduce parent ScopeState class and track the scope through the state in the parser (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: Add module() helper Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« src/parsing/parser-base.h ('K') | « src/parsing/preparser.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2011 the V8 project authors. All rights reserved. 1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <cmath> 5 #include <cmath>
6 6
7 #include "src/allocation.h" 7 #include "src/allocation.h"
8 #include "src/base/logging.h" 8 #include "src/base/logging.h"
9 #include "src/conversions-inl.h" 9 #include "src/conversions-inl.h"
10 #include "src/conversions.h" 10 #include "src/conversions.h"
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
102 } 102 }
103 103
104 PreParser::PreParseResult PreParser::PreParseLazyFunction( 104 PreParser::PreParseResult PreParser::PreParseLazyFunction(
105 LanguageMode language_mode, FunctionKind kind, bool has_simple_parameters, 105 LanguageMode language_mode, FunctionKind kind, bool has_simple_parameters,
106 bool parsing_module, ParserRecorder* log, Scanner::BookmarkScope* bookmark, 106 bool parsing_module, ParserRecorder* log, Scanner::BookmarkScope* bookmark,
107 int* use_counts) { 107 int* use_counts) {
108 parsing_module_ = parsing_module; 108 parsing_module_ = parsing_module;
109 log_ = log; 109 log_ = log;
110 use_counts_ = use_counts; 110 use_counts_ = use_counts;
111 // Lazy functions always have trivial outer scopes (no with/catch scopes). 111 // Lazy functions always have trivial outer scopes (no with/catch scopes).
112 Scope* top_scope = NewScope(scope_, SCRIPT_SCOPE); 112 DCHECK_NULL(state_);
113 PreParserFactory top_factory(NULL); 113 Scope* top_scope = NewScope(nullptr, SCRIPT_SCOPE);
114 FunctionState top_state(&function_state_, &scope_, top_scope, kNormalFunction, 114 PreParserFactory top_factory(nullptr);
115 FunctionState top_state(&function_state_, &state_, top_scope, kNormalFunction,
115 &top_factory); 116 &top_factory);
116 scope_->SetLanguageMode(language_mode); 117 scope()->SetLanguageMode(language_mode);
117 Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE, kind); 118 Scope* function_scope = NewScope(scope(), FUNCTION_SCOPE, kind);
118 if (!has_simple_parameters) function_scope->SetHasNonSimpleParameters(); 119 if (!has_simple_parameters) function_scope->SetHasNonSimpleParameters();
119 PreParserFactory function_factory(NULL); 120 PreParserFactory function_factory(nullptr);
120 FunctionState function_state(&function_state_, &scope_, function_scope, kind, 121 FunctionState function_state(&function_state_, &state_, function_scope, kind,
121 &function_factory); 122 &function_factory);
122 DCHECK_EQ(Token::LBRACE, scanner()->current_token()); 123 DCHECK_EQ(Token::LBRACE, scanner()->current_token());
123 bool ok = true; 124 bool ok = true;
124 int start_position = peek_position(); 125 int start_position = peek_position();
125 ParseLazyFunctionLiteralBody(&ok, bookmark); 126 ParseLazyFunctionLiteralBody(&ok, bookmark);
126 use_counts_ = nullptr; 127 use_counts_ = nullptr;
127 if (bookmark && bookmark->HasBeenReset()) { 128 if (bookmark && bookmark->HasBeenReset()) {
128 // Do nothing, as we've just aborted scanning this function. 129 // Do nothing, as we've just aborted scanning this function.
129 } else if (stack_overflow()) { 130 } else if (stack_overflow()) {
130 return kPreParseStackOverflow; 131 return kPreParseStackOverflow;
131 } else if (!ok) { 132 } else if (!ok) {
132 ReportUnexpectedToken(scanner()->current_token()); 133 ReportUnexpectedToken(scanner()->current_token());
133 } else { 134 } else {
134 DCHECK_EQ(Token::RBRACE, scanner()->peek()); 135 DCHECK_EQ(Token::RBRACE, scanner()->peek());
135 if (is_strict(scope_->language_mode())) { 136 if (is_strict(scope()->language_mode())) {
136 int end_pos = scanner()->location().end_pos; 137 int end_pos = scanner()->location().end_pos;
137 CheckStrictOctalLiteral(start_position, end_pos, &ok); 138 CheckStrictOctalLiteral(start_position, end_pos, &ok);
138 CheckDecimalLiteralWithLeadingZero(use_counts, start_position, end_pos); 139 CheckDecimalLiteralWithLeadingZero(use_counts, start_position, end_pos);
139 if (!ok) return kPreParseSuccess; 140 if (!ok) return kPreParseSuccess;
140 } 141 }
141 } 142 }
142 return kPreParseSuccess; 143 return kPreParseSuccess;
143 } 144 }
144 145
145 PreParserExpression PreParserTraits::ParseClassLiteral( 146 PreParserExpression PreParserTraits::ParseClassLiteral(
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
226 } 227 }
227 bool starts_with_identifier = peek() == Token::IDENTIFIER; 228 bool starts_with_identifier = peek() == Token::IDENTIFIER;
228 Scanner::Location token_loc = scanner()->peek_location(); 229 Scanner::Location token_loc = scanner()->peek_location();
229 Statement statement = ParseStatementListItem(ok); 230 Statement statement = ParseStatementListItem(ok);
230 if (!*ok) return; 231 if (!*ok) return;
231 232
232 if (directive_prologue) { 233 if (directive_prologue) {
233 bool use_strict_found = statement.IsUseStrictLiteral(); 234 bool use_strict_found = statement.IsUseStrictLiteral();
234 235
235 if (use_strict_found) { 236 if (use_strict_found) {
236 scope_->SetLanguageMode( 237 scope()->SetLanguageMode(
237 static_cast<LanguageMode>(scope_->language_mode() | STRICT)); 238 static_cast<LanguageMode>(scope()->language_mode() | STRICT));
238 } else if (!statement.IsStringLiteral()) { 239 } else if (!statement.IsStringLiteral()) {
239 directive_prologue = false; 240 directive_prologue = false;
240 } 241 }
241 242
242 if (use_strict_found && !scope_->HasSimpleParameters()) { 243 if (use_strict_found && !scope()->HasSimpleParameters()) {
243 // TC39 deemed "use strict" directives to be an error when occurring 244 // TC39 deemed "use strict" directives to be an error when occurring
244 // in the body of a function with non-simple parameter list, on 245 // in the body of a function with non-simple parameter list, on
245 // 29/7/2015. https://goo.gl/ueA7Ln 246 // 29/7/2015. https://goo.gl/ueA7Ln
246 PreParserTraits::ReportMessageAt( 247 PreParserTraits::ReportMessageAt(
247 token_loc, MessageTemplate::kIllegalLanguageModeDirective, 248 token_loc, MessageTemplate::kIllegalLanguageModeDirective,
248 "use strict"); 249 "use strict");
249 *ok = false; 250 *ok = false;
250 return; 251 return;
251 } 252 }
252 } 253 }
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
285 return Statement::Default(); 286 return Statement::Default();
286 } 287 }
287 return ParseSubStatement(allow_function, ok); 288 return ParseSubStatement(allow_function, ok);
288 } 289 }
289 290
290 PreParser::Statement PreParser::ParseScopedStatement(bool legacy, bool* ok) { 291 PreParser::Statement PreParser::ParseScopedStatement(bool legacy, bool* ok) {
291 if (is_strict(language_mode()) || peek() != Token::FUNCTION || 292 if (is_strict(language_mode()) || peek() != Token::FUNCTION ||
292 (legacy && allow_harmony_restrictive_declarations())) { 293 (legacy && allow_harmony_restrictive_declarations())) {
293 return ParseSubStatement(kDisallowLabelledFunctionStatement, ok); 294 return ParseSubStatement(kDisallowLabelledFunctionStatement, ok);
294 } else { 295 } else {
295 Scope* body_scope = NewScope(scope_, BLOCK_SCOPE); 296 Scope* body_scope = NewScope(scope(), BLOCK_SCOPE);
296 BlockState block_state(&scope_, body_scope); 297 BlockState block_state(&state_, body_scope);
297 return ParseFunctionDeclaration(ok); 298 return ParseFunctionDeclaration(ok);
298 } 299 }
299 } 300 }
300 301
301 PreParser::Statement PreParser::ParseSubStatement( 302 PreParser::Statement PreParser::ParseSubStatement(
302 AllowLabelledFunctionStatement allow_function, bool* ok) { 303 AllowLabelledFunctionStatement allow_function, bool* ok) {
303 // Statement :: 304 // Statement ::
304 // Block 305 // Block
305 // VariableStatement 306 // VariableStatement
306 // EmptyStatement 307 // EmptyStatement
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after
456 ParseClassLiteral(nullptr, name, scanner()->location(), is_strict_reserved, 457 ParseClassLiteral(nullptr, name, scanner()->location(), is_strict_reserved,
457 pos, CHECK_OK); 458 pos, CHECK_OK);
458 return Statement::Default(); 459 return Statement::Default();
459 } 460 }
460 461
461 462
462 PreParser::Statement PreParser::ParseBlock(bool* ok) { 463 PreParser::Statement PreParser::ParseBlock(bool* ok) {
463 // Block :: 464 // Block ::
464 // '{' StatementList '}' 465 // '{' StatementList '}'
465 466
466 Scope* block_scope = NewScope(scope_, BLOCK_SCOPE); 467 Scope* block_scope = NewScope(scope(), BLOCK_SCOPE);
467 Expect(Token::LBRACE, CHECK_OK); 468 Expect(Token::LBRACE, CHECK_OK);
468 Statement final = Statement::Default(); 469 Statement final = Statement::Default();
469 { 470 {
470 BlockState block_state(&scope_, block_scope); 471 BlockState block_state(&state_, block_scope);
471 while (peek() != Token::RBRACE) { 472 while (peek() != Token::RBRACE) {
472 final = ParseStatementListItem(CHECK_OK); 473 final = ParseStatementListItem(CHECK_OK);
473 } 474 }
474 } 475 }
475 Expect(Token::RBRACE, ok); 476 Expect(Token::RBRACE, ok);
476 return final; 477 return final;
477 } 478 }
478 479
479 480
480 PreParser::Statement PreParser::ParseVariableStatement( 481 PreParser::Statement PreParser::ParseVariableStatement(
(...skipping 289 matching lines...) Expand 10 before | Expand all | Expand 10 after
770 Expect(Token::WITH, CHECK_OK); 771 Expect(Token::WITH, CHECK_OK);
771 if (is_strict(language_mode())) { 772 if (is_strict(language_mode())) {
772 ReportMessageAt(scanner()->location(), MessageTemplate::kStrictWith); 773 ReportMessageAt(scanner()->location(), MessageTemplate::kStrictWith);
773 *ok = false; 774 *ok = false;
774 return Statement::Default(); 775 return Statement::Default();
775 } 776 }
776 Expect(Token::LPAREN, CHECK_OK); 777 Expect(Token::LPAREN, CHECK_OK);
777 ParseExpression(true, CHECK_OK); 778 ParseExpression(true, CHECK_OK);
778 Expect(Token::RPAREN, CHECK_OK); 779 Expect(Token::RPAREN, CHECK_OK);
779 780
780 Scope* with_scope = NewScope(scope_, WITH_SCOPE); 781 Scope* with_scope = NewScope(scope(), WITH_SCOPE);
781 BlockState block_state(&scope_, with_scope); 782 BlockState block_state(&state_, with_scope);
782 ParseScopedStatement(true, CHECK_OK); 783 ParseScopedStatement(true, CHECK_OK);
783 return Statement::Default(); 784 return Statement::Default();
784 } 785 }
785 786
786 787
787 PreParser::Statement PreParser::ParseSwitchStatement(bool* ok) { 788 PreParser::Statement PreParser::ParseSwitchStatement(bool* ok) {
788 // SwitchStatement :: 789 // SwitchStatement ::
789 // 'switch' '(' Expression ')' '{' CaseClause* '}' 790 // 'switch' '(' Expression ')' '{' CaseClause* '}'
790 791
791 Expect(Token::SWITCH, CHECK_OK); 792 Expect(Token::SWITCH, CHECK_OK);
792 Expect(Token::LPAREN, CHECK_OK); 793 Expect(Token::LPAREN, CHECK_OK);
793 ParseExpression(true, CHECK_OK); 794 ParseExpression(true, CHECK_OK);
794 Expect(Token::RPAREN, CHECK_OK); 795 Expect(Token::RPAREN, CHECK_OK);
795 796
796 Scope* cases_scope = NewScope(scope_, BLOCK_SCOPE); 797 Scope* cases_scope = NewScope(scope(), BLOCK_SCOPE);
797 { 798 {
798 BlockState cases_block_state(&scope_, cases_scope); 799 BlockState cases_block_state(&state_, cases_scope);
799 Expect(Token::LBRACE, CHECK_OK); 800 Expect(Token::LBRACE, CHECK_OK);
800 Token::Value token = peek(); 801 Token::Value token = peek();
801 while (token != Token::RBRACE) { 802 while (token != Token::RBRACE) {
802 if (token == Token::CASE) { 803 if (token == Token::CASE) {
803 Expect(Token::CASE, CHECK_OK); 804 Expect(Token::CASE, CHECK_OK);
804 ParseExpression(true, CHECK_OK); 805 ParseExpression(true, CHECK_OK);
805 } else { 806 } else {
806 Expect(Token::DEFAULT, CHECK_OK); 807 Expect(Token::DEFAULT, CHECK_OK);
807 } 808 }
808 Expect(Token::COLON, CHECK_OK); 809 Expect(Token::COLON, CHECK_OK);
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
847 ParseScopedStatement(true, ok); 848 ParseScopedStatement(true, ok);
848 return Statement::Default(); 849 return Statement::Default();
849 } 850 }
850 851
851 852
852 PreParser::Statement PreParser::ParseForStatement(bool* ok) { 853 PreParser::Statement PreParser::ParseForStatement(bool* ok) {
853 // ForStatement :: 854 // ForStatement ::
854 // 'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement 855 // 'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
855 856
856 // Create an in-between scope for let-bound iteration variables. 857 // Create an in-between scope for let-bound iteration variables.
857 Scope* for_scope = NewScope(scope_, BLOCK_SCOPE); 858 Scope* for_scope = NewScope(scope(), BLOCK_SCOPE);
858 bool has_lexical = false; 859 bool has_lexical = false;
859 860
860 BlockState block_state(&scope_, for_scope); 861 BlockState block_state(&state_, for_scope);
861 Expect(Token::FOR, CHECK_OK); 862 Expect(Token::FOR, CHECK_OK);
862 Expect(Token::LPAREN, CHECK_OK); 863 Expect(Token::LPAREN, CHECK_OK);
863 if (peek() != Token::SEMICOLON) { 864 if (peek() != Token::SEMICOLON) {
864 ForEachStatement::VisitMode mode; 865 ForEachStatement::VisitMode mode;
865 if (peek() == Token::VAR || peek() == Token::CONST || 866 if (peek() == Token::VAR || peek() == Token::CONST ||
866 (peek() == Token::LET && IsNextLetKeyword())) { 867 (peek() == Token::LET && IsNextLetKeyword())) {
867 int decl_count; 868 int decl_count;
868 bool is_lexical; 869 bool is_lexical;
869 bool is_binding_pattern; 870 bool is_binding_pattern;
870 Scanner::Location first_initializer_loc = Scanner::Location::invalid(); 871 Scanner::Location first_initializer_loc = Scanner::Location::invalid();
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
938 939
939 if (mode == ForEachStatement::ITERATE) { 940 if (mode == ForEachStatement::ITERATE) {
940 ExpressionClassifier classifier(this); 941 ExpressionClassifier classifier(this);
941 ParseAssignmentExpression(true, &classifier, CHECK_OK); 942 ParseAssignmentExpression(true, &classifier, CHECK_OK);
942 RewriteNonPattern(&classifier, CHECK_OK); 943 RewriteNonPattern(&classifier, CHECK_OK);
943 } else { 944 } else {
944 ParseExpression(true, CHECK_OK); 945 ParseExpression(true, CHECK_OK);
945 } 946 }
946 947
947 Expect(Token::RPAREN, CHECK_OK); 948 Expect(Token::RPAREN, CHECK_OK);
948 Scope* body_scope = NewScope(scope_, BLOCK_SCOPE); 949 Scope* body_scope = NewScope(scope(), BLOCK_SCOPE);
949 { 950 {
950 BlockState block_state(&scope_, body_scope); 951 BlockState block_state(&state_, body_scope);
951 ParseScopedStatement(true, CHECK_OK); 952 ParseScopedStatement(true, CHECK_OK);
952 } 953 }
953 return Statement::Default(); 954 return Statement::Default();
954 } 955 }
955 } 956 }
956 } 957 }
957 958
958 // Parsed initializer at this point. 959 // Parsed initializer at this point.
959 Expect(Token::SEMICOLON, CHECK_OK); 960 Expect(Token::SEMICOLON, CHECK_OK);
960 961
961 // If there are let bindings, then condition and the next statement of the 962 // If there are let bindings, then condition and the next statement of the
962 // for loop must be parsed in a new scope. 963 // for loop must be parsed in a new scope.
963 Scope* inner_scope = scope_; 964 Scope* inner_scope = scope();
964 if (has_lexical) inner_scope = NewScope(for_scope, BLOCK_SCOPE); 965 if (has_lexical) inner_scope = NewScope(for_scope, BLOCK_SCOPE);
965 966
966 { 967 {
967 BlockState block_state(&scope_, inner_scope); 968 BlockState block_state(&state_, inner_scope);
968 969
969 if (peek() != Token::SEMICOLON) { 970 if (peek() != Token::SEMICOLON) {
970 ParseExpression(true, CHECK_OK); 971 ParseExpression(true, CHECK_OK);
971 } 972 }
972 Expect(Token::SEMICOLON, CHECK_OK); 973 Expect(Token::SEMICOLON, CHECK_OK);
973 974
974 if (peek() != Token::RPAREN) { 975 if (peek() != Token::RPAREN) {
975 ParseExpression(true, CHECK_OK); 976 ParseExpression(true, CHECK_OK);
976 } 977 }
977 Expect(Token::RPAREN, CHECK_OK); 978 Expect(Token::RPAREN, CHECK_OK);
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
1022 if (tok != Token::CATCH && tok != Token::FINALLY) { 1023 if (tok != Token::CATCH && tok != Token::FINALLY) {
1023 ReportMessageAt(scanner()->location(), MessageTemplate::kNoCatchOrFinally); 1024 ReportMessageAt(scanner()->location(), MessageTemplate::kNoCatchOrFinally);
1024 *ok = false; 1025 *ok = false;
1025 return Statement::Default(); 1026 return Statement::Default();
1026 } 1027 }
1027 TailCallExpressionList tail_call_expressions_in_catch_block(zone()); 1028 TailCallExpressionList tail_call_expressions_in_catch_block(zone());
1028 bool catch_block_exists = false; 1029 bool catch_block_exists = false;
1029 if (tok == Token::CATCH) { 1030 if (tok == Token::CATCH) {
1030 Consume(Token::CATCH); 1031 Consume(Token::CATCH);
1031 Expect(Token::LPAREN, CHECK_OK); 1032 Expect(Token::LPAREN, CHECK_OK);
1032 Scope* catch_scope = NewScope(scope_, CATCH_SCOPE); 1033 Scope* catch_scope = NewScope(scope(), CATCH_SCOPE);
1033 ExpressionClassifier pattern_classifier(this); 1034 ExpressionClassifier pattern_classifier(this);
1034 ParsePrimaryExpression(&pattern_classifier, CHECK_OK); 1035 ParsePrimaryExpression(&pattern_classifier, CHECK_OK);
1035 ValidateBindingPattern(&pattern_classifier, CHECK_OK); 1036 ValidateBindingPattern(&pattern_classifier, CHECK_OK);
1036 Expect(Token::RPAREN, CHECK_OK); 1037 Expect(Token::RPAREN, CHECK_OK);
1037 { 1038 {
1038 CollectExpressionsInTailPositionToListScope 1039 CollectExpressionsInTailPositionToListScope
1039 collect_tail_call_expressions_scope( 1040 collect_tail_call_expressions_scope(
1040 function_state_, &tail_call_expressions_in_catch_block); 1041 function_state_, &tail_call_expressions_in_catch_block);
1041 BlockState block_state(&scope_, catch_scope); 1042 BlockState block_state(&state_, catch_scope);
1042 Scope* block_scope = NewScope(scope_, BLOCK_SCOPE); 1043 Scope* block_scope = NewScope(scope(), BLOCK_SCOPE);
1043 { 1044 {
1044 BlockState block_state(&scope_, block_scope); 1045 BlockState block_state(&state_, block_scope);
1045 ParseBlock(CHECK_OK); 1046 ParseBlock(CHECK_OK);
1046 } 1047 }
1047 } 1048 }
1048 catch_block_exists = true; 1049 catch_block_exists = true;
1049 tok = peek(); 1050 tok = peek();
1050 } 1051 }
1051 if (tok == Token::FINALLY) { 1052 if (tok == Token::FINALLY) {
1052 Consume(Token::FINALLY); 1053 Consume(Token::FINALLY);
1053 ParseBlock(CHECK_OK); 1054 ParseBlock(CHECK_OK);
1054 if (FLAG_harmony_explicit_tailcalls && catch_block_exists && 1055 if (FLAG_harmony_explicit_tailcalls && catch_block_exists &&
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
1088 1089
1089 PreParser::Expression PreParser::ParseFunctionLiteral( 1090 PreParser::Expression PreParser::ParseFunctionLiteral(
1090 Identifier function_name, Scanner::Location function_name_location, 1091 Identifier function_name, Scanner::Location function_name_location,
1091 FunctionNameValidity function_name_validity, FunctionKind kind, 1092 FunctionNameValidity function_name_validity, FunctionKind kind,
1092 int function_token_pos, FunctionLiteral::FunctionType function_type, 1093 int function_token_pos, FunctionLiteral::FunctionType function_type,
1093 LanguageMode language_mode, bool* ok) { 1094 LanguageMode language_mode, bool* ok) {
1094 // Function :: 1095 // Function ::
1095 // '(' FormalParameterList? ')' '{' FunctionBody '}' 1096 // '(' FormalParameterList? ')' '{' FunctionBody '}'
1096 1097
1097 // Parse function body. 1098 // Parse function body.
1098 bool outer_is_script_scope = scope_->is_script_scope(); 1099 bool outer_is_script_scope = scope()->is_script_scope();
1099 Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE, kind); 1100 Scope* function_scope = NewScope(scope(), FUNCTION_SCOPE, kind);
1100 function_scope->SetLanguageMode(language_mode); 1101 function_scope->SetLanguageMode(language_mode);
1101 PreParserFactory factory(NULL); 1102 PreParserFactory factory(NULL);
1102 FunctionState function_state(&function_state_, &scope_, function_scope, kind, 1103 FunctionState function_state(&function_state_, &state_, function_scope, kind,
1103 &factory); 1104 &factory);
1104 DuplicateFinder duplicate_finder(scanner()->unicode_cache()); 1105 DuplicateFinder duplicate_finder(scanner()->unicode_cache());
1105 ExpressionClassifier formals_classifier(this, &duplicate_finder); 1106 ExpressionClassifier formals_classifier(this, &duplicate_finder);
1106 1107
1107 Expect(Token::LPAREN, CHECK_OK); 1108 Expect(Token::LPAREN, CHECK_OK);
1108 int start_position = scanner()->location().beg_pos; 1109 int start_position = scanner()->location().beg_pos;
1109 function_scope->set_start_position(start_position); 1110 function_scope->set_start_position(start_position);
1110 PreParserFormalParameters formals(function_scope); 1111 PreParserFormalParameters formals(function_scope);
1111 ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK); 1112 ParseFormalParameterList(&formals, &formals_classifier, CHECK_OK);
1112 Expect(Token::RPAREN, CHECK_OK); 1113 Expect(Token::RPAREN, CHECK_OK);
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
1188 ParseStatementList(Token::RBRACE, ok, bookmark); 1189 ParseStatementList(Token::RBRACE, ok, bookmark);
1189 if (!*ok) return; 1190 if (!*ok) return;
1190 if (bookmark && bookmark->HasBeenReset()) return; 1191 if (bookmark && bookmark->HasBeenReset()) return;
1191 1192
1192 // Position right after terminal '}'. 1193 // Position right after terminal '}'.
1193 DCHECK_EQ(Token::RBRACE, scanner()->peek()); 1194 DCHECK_EQ(Token::RBRACE, scanner()->peek());
1194 int body_end = scanner()->peek_location().end_pos; 1195 int body_end = scanner()->peek_location().end_pos;
1195 log_->LogFunction(body_start, body_end, 1196 log_->LogFunction(body_start, body_end,
1196 function_state_->materialized_literal_count(), 1197 function_state_->materialized_literal_count(),
1197 function_state_->expected_property_count(), language_mode(), 1198 function_state_->expected_property_count(), language_mode(),
1198 scope_->uses_super_property(), scope_->calls_eval()); 1199 scope()->uses_super_property(), scope()->calls_eval());
1199 } 1200 }
1200 1201
1201 PreParserExpression PreParser::ParseClassLiteral( 1202 PreParserExpression PreParser::ParseClassLiteral(
1202 ExpressionClassifier* classifier, PreParserIdentifier name, 1203 ExpressionClassifier* classifier, PreParserIdentifier name,
1203 Scanner::Location class_name_location, bool name_is_strict_reserved, 1204 Scanner::Location class_name_location, bool name_is_strict_reserved,
1204 int pos, bool* ok) { 1205 int pos, bool* ok) {
1205 // All parts of a ClassDeclaration and ClassExpression are strict code. 1206 // All parts of a ClassDeclaration and ClassExpression are strict code.
1206 if (name_is_strict_reserved) { 1207 if (name_is_strict_reserved) {
1207 ReportMessageAt(class_name_location, 1208 ReportMessageAt(class_name_location,
1208 MessageTemplate::kUnexpectedStrictReserved); 1209 MessageTemplate::kUnexpectedStrictReserved);
1209 *ok = false; 1210 *ok = false;
1210 return EmptyExpression(); 1211 return EmptyExpression();
1211 } 1212 }
1212 if (IsEvalOrArguments(name)) { 1213 if (IsEvalOrArguments(name)) {
1213 ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments); 1214 ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments);
1214 *ok = false; 1215 *ok = false;
1215 return EmptyExpression(); 1216 return EmptyExpression();
1216 } 1217 }
1217 1218
1218 LanguageMode class_language_mode = language_mode(); 1219 LanguageMode class_language_mode = language_mode();
1219 Scope* scope = NewScope(scope_, BLOCK_SCOPE); 1220 Scope* scope = NewScope(this->scope(), BLOCK_SCOPE);
1220 BlockState block_state(&scope_, scope); 1221 BlockState block_state(&state_, scope);
1221 scope_->SetLanguageMode( 1222 this->scope()->SetLanguageMode(
1222 static_cast<LanguageMode>(class_language_mode | STRICT)); 1223 static_cast<LanguageMode>(class_language_mode | STRICT));
1223 // TODO(marja): Make PreParser use scope names too. 1224 // TODO(marja): Make PreParser use scope names too.
1224 // scope_->SetScopeName(name); 1225 // this->scope()->SetScopeName(name);
1225 1226
1226 bool has_extends = Check(Token::EXTENDS); 1227 bool has_extends = Check(Token::EXTENDS);
1227 if (has_extends) { 1228 if (has_extends) {
1228 ExpressionClassifier extends_classifier(this); 1229 ExpressionClassifier extends_classifier(this);
1229 ParseLeftHandSideExpression(&extends_classifier, CHECK_OK); 1230 ParseLeftHandSideExpression(&extends_classifier, CHECK_OK);
1230 CheckNoTailCallExpressions(&extends_classifier, CHECK_OK); 1231 CheckNoTailCallExpressions(&extends_classifier, CHECK_OK);
1231 ValidateExpression(&extends_classifier, CHECK_OK); 1232 ValidateExpression(&extends_classifier, CHECK_OK);
1232 if (classifier != nullptr) { 1233 if (classifier != nullptr) {
1233 classifier->Accumulate(&extends_classifier, 1234 classifier->Accumulate(&extends_classifier,
1234 ExpressionClassifier::ExpressionProductions); 1235 ExpressionClassifier::ExpressionProductions);
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
1291 while (peek() != Token::RBRACE) { 1292 while (peek() != Token::RBRACE) {
1292 ParseStatementListItem(CHECK_OK); 1293 ParseStatementListItem(CHECK_OK);
1293 } 1294 }
1294 Expect(Token::RBRACE, CHECK_OK); 1295 Expect(Token::RBRACE, CHECK_OK);
1295 return PreParserExpression::Default(); 1296 return PreParserExpression::Default();
1296 } 1297 }
1297 1298
1298 void PreParserTraits::ParseAsyncArrowSingleExpressionBody( 1299 void PreParserTraits::ParseAsyncArrowSingleExpressionBody(
1299 PreParserStatementList body, bool accept_IN, 1300 PreParserStatementList body, bool accept_IN,
1300 Type::ExpressionClassifier* classifier, int pos, bool* ok) { 1301 Type::ExpressionClassifier* classifier, int pos, bool* ok) {
1301 Scope* scope = pre_parser_->scope_; 1302 Scope* scope = pre_parser_->scope();
1302 scope->ForceContextAllocation(); 1303 scope->ForceContextAllocation();
1303 1304
1304 PreParserExpression return_value = 1305 PreParserExpression return_value =
1305 pre_parser_->ParseAssignmentExpression(accept_IN, classifier, ok); 1306 pre_parser_->ParseAssignmentExpression(accept_IN, classifier, ok);
1306 if (!*ok) return; 1307 if (!*ok) return;
1307 1308
1308 body->Add(PreParserStatement::ExpressionStatement(return_value), zone()); 1309 body->Add(PreParserStatement::ExpressionStatement(return_value), zone());
1309 } 1310 }
1310 1311
1311 #undef CHECK_OK 1312 #undef CHECK_OK
1312 1313
1313 1314
1314 } // namespace internal 1315 } // namespace internal
1315 } // namespace v8 1316 } // namespace v8
OLDNEW
« src/parsing/parser-base.h ('K') | « src/parsing/preparser.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698