AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[parser] More CHECK_OK cleanup.

Browse Source 
In parser.{cc,h}, replace CHECK_OK_CUSTOM by CHECK_OK_VOID, as that's all we need.
Use this to convert all void* functions to void.

R=adamk@chromium.org, nikolaos@chromium.org
BUG=

Review-Url: https://codereview.chromium.org/2165513004
Cr-Commit-Position: refs/heads/master@{#37878}
This commit is contained in:
neis 2016-07-19 12:45:50 -07:00 committed by Commit bot
parent a660062de5
commit cde66a896e
2 changed files with 55 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
src/parsing/parser.cc
View File

@ -329,21 +329,20 @@ class TargetScope BASE_EMBEDDED {
// thus it must never be used where only a single statement
// is correct (e.g. an if statement branch w/o braces)!
#define CHECK_OK ok); \
if (!*ok) return NULL; \
#define CHECK_OK ok); \
if (!*ok) return nullptr; \
((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(); \
#define CHECK_OK_VOID ok); \
if (!*ok) return; \
((void)0
#define DUMMY ) // to make indentation work
#undef DUMMY
#define CHECK_FAILED /**/); \
if (failed_) return NULL; \
if (failed_) return nullptr; \
((void)0
#define DUMMY ) // to make indentation work
#undef DUMMY
@ -1222,8 +1221,8 @@ FunctionLiteral* Parser::ParseLazy(Isolate* isolate, ParseInfo* info,
}
void* Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
bool* ok) {
void Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
bool* ok) {
// StatementList ::
// (StatementListItem)* <end_token>
@ -1242,7 +1241,7 @@ void* Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
}
Scanner::Location token_loc = scanner()->peek_location();
Statement* stat = ParseStatementListItem(CHECK_OK);
Statement* stat = ParseStatementListItem(CHECK_OK_VOID);
if (stat == NULL || stat->IsEmpty()) {
directive_prologue = false; // End of directive prologue.
continue;
@ -1276,7 +1275,7 @@ void* Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
token_loc, MessageTemplate::kIllegalLanguageModeDirective,
string);
*ok = false;
return nullptr;
return;
}
// Because declarations in strict eval code don't leak into the scope
// of the eval call, it is likely that functions declared in strict
@ -1307,8 +1306,6 @@ void* Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
body->Add(stat, zone());
}
return 0;
}
@ -1366,7 +1363,7 @@ Statement* Parser::ParseModuleItem(bool* ok) {
}
void* Parser::ParseModuleItemList(ZoneList<Statement*>* body, bool* ok) {
void Parser::ParseModuleItemList(ZoneList<Statement*>* body, bool* ok) {
// ecma262/#prod-Module
// Module :
// ModuleBody?
@ -1377,12 +1374,11 @@ void* Parser::ParseModuleItemList(ZoneList<Statement*>* body, bool* ok) {
DCHECK(scope()->is_module_scope());
while (peek() != Token::EOS) {
Statement* stat = ParseModuleItem(CHECK_OK);
Statement* stat = ParseModuleItem(CHECK_OK_VOID);
if (stat && !stat->IsEmpty()) {
body->Add(stat, zone());
}
}
return nullptr;
}
@ -1395,10 +1391,10 @@ const AstRawString* Parser::ParseModuleSpecifier(bool* ok) {
}
void* Parser::ParseExportClause(ZoneList<const AstRawString*>* export_names,
ZoneList<Scanner::Location>* export_locations,
ZoneList<const AstRawString*>* local_names,
Scanner::Location* reserved_loc, bool* ok) {
void Parser::ParseExportClause(ZoneList<const AstRawString*>* export_names,
ZoneList<Scanner::Location>* export_locations,
ZoneList<const AstRawString*>* local_names,
Scanner::Location* reserved_loc, bool* ok) {
// ExportClause :
// '{' '}'
// '{' ExportsList '}'
@ -1412,7 +1408,7 @@ void* Parser::ParseExportClause(ZoneList<const AstRawString*>* export_names,
// IdentifierName
// IdentifierName 'as' IdentifierName
Expect(Token::LBRACE, CHECK_OK);
Expect(Token::LBRACE, CHECK_OK_VOID);
Token::Value name_tok;
while ((name_tok = peek()) != Token::RBRACE) {
@ -1422,10 +1418,10 @@ void* Parser::ParseExportClause(ZoneList<const AstRawString*>* export_names,
!Token::IsIdentifier(name_tok, STRICT, false, parsing_module_)) {
*reserved_loc = scanner()->location();
}
const AstRawString* local_name = ParseIdentifierName(CHECK_OK);
const AstRawString* local_name = ParseIdentifierName(CHECK_OK_VOID);
const AstRawString* export_name = NULL;
if (CheckContextualKeyword(CStrVector("as"))) {
export_name = ParseIdentifierName(CHECK_OK);
export_name = ParseIdentifierName(CHECK_OK_VOID);
}
if (export_name == NULL) {
export_name = local_name;
@ -1434,12 +1430,10 @@ void* Parser::ParseExportClause(ZoneList<const AstRawString*>* export_names,
local_names->Add(local_name, zone());
export_locations->Add(scanner()->location(), zone());
if (peek() == Token::RBRACE) break;
Expect(Token::COMMA, CHECK_OK);
Expect(Token::COMMA, CHECK_OK_VOID);
}
Expect(Token::RBRACE, CHECK_OK);
return nullptr;
Expect(Token::RBRACE, CHECK_OK_VOID);
}
@ -1496,7 +1490,7 @@ ZoneList<const Parser::NamedImport*>* Parser::ParseNamedImports(
}
void* Parser::ParseImportDeclaration(bool* ok) {
void Parser::ParseImportDeclaration(bool* ok) {
// ImportDeclaration :
// 'import' ImportClause 'from' ModuleSpecifier ';'
// 'import' ModuleSpecifier ';'
@ -1512,16 +1506,16 @@ void* Parser::ParseImportDeclaration(bool* ok) {
// '*' 'as' ImportedBinding
int pos = peek_position();
Expect(Token::IMPORT, CHECK_OK);
Expect(Token::IMPORT, CHECK_OK_VOID);
Token::Value tok = peek();
// 'import' ModuleSpecifier ';'
if (tok == Token::STRING) {
const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
ExpectSemicolon(CHECK_OK);
const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK_VOID);
ExpectSemicolon(CHECK_OK_VOID);
module()->AddEmptyImport(module_specifier, scanner()->location(), zone());
return nullptr;
return;
}
// Parse ImportedDefaultBinding if present.
@ -1529,9 +1523,9 @@ void* Parser::ParseImportDeclaration(bool* ok) {
Scanner::Location import_default_binding_loc;
if (tok != Token::MUL && tok != Token::LBRACE) {
import_default_binding =
ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK_VOID);
import_default_binding_loc = scanner()->location();
DeclareImport(import_default_binding, pos, CHECK_OK);
DeclareImport(import_default_binding, pos, CHECK_OK_VOID);
}
// Parse NameSpaceImport or NamedImports if present.
@ -1542,27 +1536,27 @@ void* Parser::ParseImportDeclaration(bool* ok) {
switch (peek()) {
case Token::MUL: {
Consume(Token::MUL);
ExpectContextualKeyword(CStrVector("as"), CHECK_OK);
ExpectContextualKeyword(CStrVector("as"), CHECK_OK_VOID);
module_namespace_binding =
ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK_VOID);
module_namespace_binding_loc = scanner()->location();
break;
}
case Token::LBRACE:
named_imports = ParseNamedImports(pos, CHECK_OK);
named_imports = ParseNamedImports(pos, CHECK_OK_VOID);
break;
default:
*ok = false;
ReportUnexpectedToken(scanner()->current_token());
return nullptr;
return;
}
}
ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
ExpectSemicolon(CHECK_OK);
ExpectContextualKeyword(CStrVector("from"), CHECK_OK_VOID);
const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK_VOID);
ExpectSemicolon(CHECK_OK_VOID);
// Now that we have all the information, we can make the appropriate
// declarations.
@ -1582,7 +1576,7 @@ void* Parser::ParseImportDeclaration(bool* ok) {
module()->AddImport(ast_value_factory()->default_string(),
import_default_binding, module_specifier,
import_default_binding_loc, zone());
// DeclareImport(import_default_binding, pos, CHECK_OK);
// DeclareImport(import_default_binding, pos, CHECK_OK_VOID);
}
if (named_imports != nullptr) {
@ -1593,12 +1587,10 @@ void* Parser::ParseImportDeclaration(bool* ok) {
const NamedImport* import = named_imports->at(i);
module()->AddImport(import->import_name, import->local_name,
module_specifier, import->location, zone());
// DeclareImport(import->local_name, pos, CHECK_OK);
// DeclareImport(import->local_name, pos, CHECK_OK_VOID);
}
}
}
return nullptr;
}
@ -1934,13 +1926,12 @@ VariableProxy* Parser::NewUnresolved(const AstRawString* name,
}
void* Parser::DeclareImport(const AstRawString* local_name, int pos, bool* ok) {
void Parser::DeclareImport(const AstRawString* local_name, int pos, bool* ok) {
DCHECK_NOT_NULL(local_name);
VariableProxy* proxy = NewUnresolved(local_name, IMPORT);
Declaration* declaration =
factory()->NewVariableDeclaration(proxy, IMPORT, scope(), pos);
Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
return nullptr;
Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK_VOID);
}
@ -4114,7 +4105,7 @@ void ParserTraits::ParseArrowFunctionFormalParameters(
Expression* right = binop->right();
int comma_pos = binop->position();
ParseArrowFunctionFormalParameters(parameters, left, comma_pos,
CHECK_OK_CUSTOM(Void));
CHECK_OK_VOID);
// LHS of comma expression should be unparenthesized.
expr = right;
}
@ -4193,12 +4184,12 @@ void Parser::DesugarAsyncFunctionBody(const AstRawString* function_name,
Expression* return_value = nullptr;
if (body_type == FunctionBody::Normal) {
ParseStatementList(inner_body, Token::RBRACE, CHECK_OK_CUSTOM(Void));
ParseStatementList(inner_body, Token::RBRACE, CHECK_OK_VOID);
return_value = factory()->NewUndefinedLiteral(kNoSourcePosition);
} else {
return_value =
ParseAssignmentExpression(accept_IN, classifier, CHECK_OK_CUSTOM(Void));
ParserTraits::RewriteNonPattern(classifier, CHECK_OK_CUSTOM(Void));
ParseAssignmentExpression(accept_IN, classifier, CHECK_OK_VOID);
ParserTraits::RewriteNonPattern(classifier, CHECK_OK_VOID);
}
return_value = BuildPromiseResolve(return_value, return_value->position());
@ -4235,7 +4226,7 @@ void ParserTraits::ParseArrowFunctionFormalParameterList(
if (expr->IsEmptyParentheses()) return;
ParseArrowFunctionFormalParameters(parameters, expr, params_loc.end_pos,
CHECK_OK_CUSTOM(Void));
CHECK_OK_VOID);
if (parameters->Arity() > Code::kMaxArguments) {
ReportMessageAt(params_loc, MessageTemplate::kMalformedArrowFunParamList);
@ -4558,7 +4549,7 @@ void Parser::SkipLazyFunctionBody(int* materialized_literal_count,
scanner()->SeekForward(entry.end_pos() - 1);
scope()->set_end_position(entry.end_pos());
Expect(Token::RBRACE, CHECK_OK_CUSTOM(Void));
Expect(Token::RBRACE, CHECK_OK_VOID);
total_preparse_skipped_ += scope()->end_position() - function_block_pos;
*materialized_literal_count = entry.literal_count();
*expected_property_count = entry.property_count();
@ -4591,7 +4582,7 @@ void Parser::SkipLazyFunctionBody(int* materialized_literal_count,
return;
}
scope()->set_end_position(logger.end());
Expect(Token::RBRACE, CHECK_OK_CUSTOM(Void));
Expect(Token::RBRACE, CHECK_OK_VOID);
total_preparse_skipped_ += scope()->end_position() - function_block_pos;
*materialized_literal_count = logger.literals();
*expected_property_count = logger.properties();
@ -5882,7 +5873,7 @@ class NonPatternRewriter : public AstExpressionRewriter {
void Parser::RewriteNonPattern(ExpressionClassifier* classifier, bool* ok) {
ValidateExpression(classifier, CHECK_OK_CUSTOM(Void));
ValidateExpression(classifier, CHECK_OK_VOID);
auto non_patterns_to_rewrite = function_state_->non_patterns_to_rewrite();
int begin = classifier->GetNonPatternBegin();
int end = non_patterns_to_rewrite->length();
@ -7084,7 +7075,7 @@ void Parser::Print(AstNode* node) {
#endif // DEBUG
#undef CHECK_OK
#undef CHECK_OK_CUSTOM
#undef CHECK_OK_VOID
#undef CHECK_FAILED
} // namespace internal

19
src/parsing/parser.h
View File

@ -475,9 +475,6 @@ class ParserTraits {
const AstRawString* arg,
ParseErrorType error_type = kSyntaxError);
// A dummy function, just useful as an argument to CHECK_OK_CUSTOM.
static void Void() {}
// "null" return type creators.
static const AstRawString* EmptyIdentifier() {
return NULL;
@ -765,18 +762,18 @@ class Parser : public ParserBase<ParserTraits> {
// which is set to false if parsing failed; it is unchanged otherwise.
// By making the 'exception handling' explicit, we are forced to check
// for failure at the call sites.
void* ParseStatementList(ZoneList<Statement*>* body, int end_token, bool* ok);
void ParseStatementList(ZoneList<Statement*>* body, int end_token, bool* ok);
Statement* ParseStatementListItem(bool* ok);
void* ParseModuleItemList(ZoneList<Statement*>* body, bool* ok);
void ParseModuleItemList(ZoneList<Statement*>* body, bool* ok);
Statement* ParseModuleItem(bool* ok);
const AstRawString* ParseModuleSpecifier(bool* ok);
void* ParseImportDeclaration(bool* ok);
void ParseImportDeclaration(bool* ok);
Statement* ParseExportDeclaration(bool* ok);
Statement* ParseExportDefault(bool* ok);
void* ParseExportClause(ZoneList<const AstRawString*>* export_names,
ZoneList<Scanner::Location>* export_locations,
ZoneList<const AstRawString*>* local_names,
Scanner::Location* reserved_loc, bool* ok);
void ParseExportClause(ZoneList<const AstRawString*>* export_names,
ZoneList<Scanner::Location>* export_locations,
ZoneList<const AstRawString*>* local_names,
Scanner::Location* reserved_loc, bool* ok);
struct NamedImport : public ZoneObject {
const AstRawString* import_name;
const AstRawString* local_name;
@ -1041,7 +1038,7 @@ class Parser : public ParserBase<ParserTraits> {
Variable* Declare(Declaration* declaration,
DeclarationDescriptor::Kind declaration_kind, bool resolve,
bool* ok, Scope* declaration_scope = nullptr);
void* DeclareImport(const AstRawString* local_name, int pos, bool* ok);
void DeclareImport(const AstRawString* local_name, int pos, bool* ok);
bool TargetStackContainsLabel(const AstRawString* label);
BreakableStatement* LookupBreakTarget(const AstRawString* label, bool* ok);