archive-gh-me/jerryscript
1
0
Fork 0
mirror of https://github.com/jerryscript-project/jerryscript.git synced 2025-12-15 16:29:21 +00:00
Code Issues Projects Releases Wiki Activity

Support function statements after 'if' or 'else'. (#3699)

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com
This commit is contained in:
Zoltan Herczeg 2020-04-29 13:50:01 +02:00 committed by GitHub
parent 2bdd0f5008
commit 85401db547
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 233 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
jerry-core/parser/js/js-parser-statm.c
View File

@ -72,9 +72,10 @@ typedef enum
{
PARSER_STATM_NO_OPTS = 0, /**< no options */
PARSER_STATM_SINGLE_STATM = (1 << 0), /**< statment can form single statement context */
PARSER_STATM_BREAK_TARGET = (1 << 1), /**< break target statement */
PARSER_STATM_CONTINUE_TARGET = (1 << 2), /**< continue target statement */
PARSER_STATM_CONTEXT_BREAK = (1 << 3), /**< uses another instruction form when crosses their borders */
PARSER_STATM_HAS_BLOCK = (1 << 1), /**< statement always has a code block */
PARSER_STATM_BREAK_TARGET = (1 << 2), /**< break target statement */
PARSER_STATM_CONTINUE_TARGET = (1 << 3), /**< continue target statement */
PARSER_STATM_CONTEXT_BREAK = (1 << 4), /**< uses another instruction form when crosses their borders */
} parser_statement_flags_t;
/**
@ -84,16 +85,16 @@ typedef enum
static const uint8_t parser_statement_flags[] =
{
/* PARSER_STATEMENT_START */
PARSER_STATM_NO_OPTS,
PARSER_STATM_HAS_BLOCK,
/* PARSER_STATEMENT_BLOCK, */
PARSER_STATM_NO_OPTS,
PARSER_STATM_HAS_BLOCK,
#if ENABLED (JERRY_ES2015)
/* PARSER_STATEMENT_BLOCK_SCOPE, */
PARSER_STATM_NO_OPTS,
PARSER_STATM_HAS_BLOCK,
/* PARSER_STATEMENT_PRIVATE_SCOPE, */
PARSER_STATM_NO_OPTS,
/* PARSER_STATEMENT_BLOCK_CONTEXT, */
PARSER_STATM_CONTEXT_BREAK,
PARSER_STATM_HAS_BLOCK | PARSER_STATM_CONTEXT_BREAK,
/* PARSER_STATEMENT_PRIVATE_CONTEXT, */
PARSER_STATM_NO_OPTS,
#endif /* ENABLED (JERRY_ES2015) */
@ -104,9 +105,9 @@ static const uint8_t parser_statement_flags[] =
/* PARSER_STATEMENT_ELSE */
PARSER_STATM_SINGLE_STATM,
/* PARSER_STATEMENT_SWITCH */
PARSER_STATM_BREAK_TARGET,
PARSER_STATM_HAS_BLOCK | PARSER_STATM_BREAK_TARGET,
/* PARSER_STATEMENT_SWITCH_NO_DEFAULT */
PARSER_STATM_BREAK_TARGET,
PARSER_STATM_HAS_BLOCK | PARSER_STATM_BREAK_TARGET,
/* PARSER_STATEMENT_DO_WHILE */
PARSER_STATM_BREAK_TARGET | PARSER_STATM_CONTINUE_TARGET | PARSER_STATM_SINGLE_STATM,
/* PARSER_STATEMENT_WHILE */
@ -122,7 +123,7 @@ static const uint8_t parser_statement_flags[] =
/* PARSER_STATEMENT_WITH */
PARSER_STATM_CONTEXT_BREAK | PARSER_STATM_SINGLE_STATM,
/* PARSER_STATEMENT_TRY */
PARSER_STATM_CONTEXT_BREAK
PARSER_STATM_HAS_BLOCK | PARSER_STATM_CONTEXT_BREAK
};
#if ENABLED (JERRY_ES2015)
@ -613,12 +614,47 @@ parser_parse_function_statement (parser_context_t *context_p) /**< context */
JERRY_ASSERT (context_p->token.type == LEXER_KEYW_FUNCTION);
#if ENABLED (JERRY_ES2015)
if ((parser_statement_flags[context_p->stack_top_uint8] & PARSER_STATM_SINGLE_STATM)
&& !(context_p->stack_top_uint8 == PARSER_STATEMENT_IF
|| context_p->stack_top_uint8 == PARSER_STATEMENT_ELSE
|| context_p->stack_top_uint8 == PARSER_STATEMENT_LABEL))
if (JERRY_UNLIKELY (parser_statement_flags[context_p->stack_top_uint8] & PARSER_STATM_SINGLE_STATM))
{
parser_raise_error (context_p, PARSER_ERR_LEXICAL_SINGLE_STATEMENT);
if (context_p->status_flags & PARSER_IS_STRICT)
{
parser_raise_error (context_p, PARSER_ERR_LEXICAL_SINGLE_STATEMENT);
}
if (context_p->stack_top_uint8 == PARSER_STATEMENT_IF
|| context_p->stack_top_uint8 == PARSER_STATEMENT_ELSE)
{
JERRY_ASSERT (context_p->next_scanner_info_p->source_p == context_p->source_p);
parser_push_block_context (context_p, true);
}
else if (context_p->stack_top_uint8 == PARSER_STATEMENT_LABEL)
{
parser_stack_iterator_t iterator;
parser_stack_iterator_init (context_p, &iterator);
parser_stack_iterator_skip (&iterator, sizeof (parser_label_statement_t) + 1);
while (true)
{
uint8_t type = parser_stack_iterator_read_uint8 (&iterator);
if (type == PARSER_STATEMENT_LABEL)
{
parser_stack_iterator_skip (&iterator, sizeof (parser_label_statement_t) + 1);
continue;
}
if (parser_statement_flags[type] & PARSER_STATM_HAS_BLOCK)
{
break;
}
parser_raise_error (context_p, PARSER_ERR_LABELLED_FUNC_NOT_IN_BLOCK);
}
}
else
{
parser_raise_error (context_p, PARSER_ERR_LEXICAL_SINGLE_STATEMENT);
}
}
#endif /* ENABLED (JERRY_ES2015) */
@ -741,6 +777,12 @@ parser_parse_function_statement (parser_context_t *context_p) /**< context */
parser_flush_cbc (context_p);
}
if (JERRY_UNLIKELY (context_p->stack_top_uint8 == PARSER_STATEMENT_PRIVATE_SCOPE
|| context_p->stack_top_uint8 == PARSER_STATEMENT_PRIVATE_CONTEXT))
{
parser_pop_block_context (context_p);
}
}
#endif /* ENABLED (JERRY_ES2015) */
@ -2649,6 +2691,11 @@ parser_parse_statements (parser_context_t *context_p) /**< context */
JERRY_ASSERT (context_p->stack_depth == context_p->context_stack_depth);
#endif /* !JERRY_NDEBUG */
#if ENABLED (JERRY_ES2015)
JERRY_ASSERT (context_p->stack_top_uint8 != PARSER_STATEMENT_PRIVATE_SCOPE
&& context_p->stack_top_uint8 != PARSER_STATEMENT_PRIVATE_CONTEXT);
#endif /* ENABLED (JERRY_ES2015) */
#if ENABLED (JERRY_DEBUGGER)
if (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED
&& context_p->token.line != context_p->last_breakpoint_line
@ -2990,6 +3037,11 @@ parser_parse_statements (parser_context_t *context_p) /**< context */
{
JERRY_ASSERT (context_p->next_scanner_info_p->u8_arg & SCANNER_FUNCTION_ASYNC);
if (parser_statement_flags[context_p->stack_top_uint8] & PARSER_STATM_SINGLE_STATM)
{
parser_raise_error (context_p, PARSER_ERR_LEXICAL_SINGLE_STATEMENT);
}
lexer_next_token (context_p);
JERRY_ASSERT (context_p->token.type == LEXER_KEYW_FUNCTION);
continue;

4
jerry-core/parser/js/js-parser-util.c
View File

@ -1127,6 +1127,10 @@ parser_error_to_string (parser_error_t error) /**< error code */
{
return "Lexical declaration cannot appear in a single-statement context.";
}
case PARSER_ERR_LABELLED_FUNC_NOT_IN_BLOCK:
{
return "Labelled functions are only allowed inside blocks.";
}
case PARSER_ERR_LEXICAL_LET_BINDING:
{
return "Let binding cannot appear in let/const declarations.";

1
jerry-core/parser/js/js-parser.h
View File

@ -127,6 +127,7 @@ typedef enum
#if ENABLED (JERRY_ES2015)
PARSER_ERR_VARIABLE_REDECLARED, /**< a variable redeclared */
PARSER_ERR_LEXICAL_SINGLE_STATEMENT, /**< lexical declaration in single statement context */
PARSER_ERR_LABELLED_FUNC_NOT_IN_BLOCK, /**< labelled functions are only allowed inside blocks */
PARSER_ERR_LEXICAL_LET_BINDING, /**< let binding cannot be declared in let/const */
PARSER_ERR_MISSING_ASSIGN_AFTER_CONST, /**< an assignment is required after a const declaration */

3
jerry-core/parser/js/js-scanner-internal.h
View File

@ -101,7 +101,7 @@ typedef enum
SCAN_STACK_COMPUTED_GENERATOR_FUNCTION, /**< computed property name */
SCAN_STACK_TEMPLATE_STRING, /**< template string */
SCAN_STACK_TAGGED_TEMPLATE_LITERAL, /**< tagged template literal */
SCAN_STACK_FOR_BLOCK_END, /**< end of "for" statement with let/const declaration */
SCAN_STACK_PRIVATE_BLOCK, /**< private block for single statements */
SCAN_STACK_ARROW_ARGUMENTS, /**< might be arguments of an arrow function */
SCAN_STACK_ARROW_EXPRESSION, /**< expression body of an arrow function */
SCAN_STACK_EXPLICIT_CLASS_CONSTRUCTOR, /**< explicit class constructor */
@ -365,6 +365,7 @@ void scanner_scan_simple_arrow (parser_context_t *context_p, scanner_context_t *
const uint8_t *source_p);
void scanner_check_arrow_arg (parser_context_t *context_p, scanner_context_t *scanner_context_p);
bool scanner_check_async_function (parser_context_t *context_p, scanner_context_t *scanner_context_p);
void scanner_check_function_after_if (parser_context_t *context_p, scanner_context_t *scanner_context_p);
#endif /* ENABLED (JERRY_ES2015) */
void scanner_scan_bracket (parser_context_t *context_p, scanner_context_t *scanner_context_p);
void scanner_check_directives (parser_context_t *context_p, scanner_context_t *scanner_context_p);

22
jerry-core/parser/js/js-scanner-ops.c
View File

@ -280,6 +280,28 @@ scanner_check_async_function (parser_context_t *context_p, /**< context */
return false;
} /* scanner_check_async_function */
/**
* Check whether the statement of an if/else construct is a function statement.
*/
void
scanner_check_function_after_if (parser_context_t *context_p, /**< context */
scanner_context_t *scanner_context_p) /**< scanner context */
{
lexer_next_token (context_p);
scanner_context_p->mode = SCAN_MODE_STATEMENT;
if (JERRY_UNLIKELY (context_p->token.type == LEXER_KEYW_FUNCTION))
{
scanner_literal_pool_t *literal_pool_p;
literal_pool_p = scanner_push_literal_pool (context_p,
scanner_context_p,
SCANNER_LITERAL_POOL_BLOCK);
literal_pool_p->source_p = context_p->source_p;
parser_stack_push_uint8 (context_p, SCAN_STACK_PRIVATE_BLOCK);
}
} /* scanner_check_function_after_if */
/**
* Arrow types for scanner_scan_bracket() function.
*/

22
jerry-core/parser/js/js-scanner.c
View File

@ -527,8 +527,17 @@ scanner_scan_primary_expression_end (parser_context_t *context_p, /**< context *
break;
}
scanner_context_p->mode = SCAN_MODE_STATEMENT;
parser_stack_pop_uint8 (context_p);
#if ENABLED (JERRY_ES2015)
if (context_p->stack_top_uint8 == SCAN_STACK_IF_STATEMENT)
{
scanner_check_function_after_if (context_p, scanner_context_p);
return SCAN_KEEP_TOKEN;
}
#endif /* ENABLED (JERRY_ES2015) */
scanner_context_p->mode = SCAN_MODE_STATEMENT;
return SCAN_NEXT_TOKEN;
}
#if ENABLED (JERRY_ES2015)
@ -636,7 +645,7 @@ scanner_scan_primary_expression_end (parser_context_t *context_p, /**< context *
if (stack_top == SCAN_STACK_FOR_LET_START || stack_top == SCAN_STACK_FOR_CONST_START)
{
parser_stack_push_uint8 (context_p, SCAN_STACK_FOR_BLOCK_END);
parser_stack_push_uint8 (context_p, SCAN_STACK_PRIVATE_BLOCK);
}
#else /* !ENABLED (JERRY_ES2015) */
location_info->info.type = SCANNER_TYPE_FOR_IN;
@ -662,7 +671,7 @@ scanner_scan_primary_expression_end (parser_context_t *context_p, /**< context *
#if ENABLED (JERRY_ES2015)
if (stack_top == SCAN_STACK_FOR_LET_START || stack_top == SCAN_STACK_FOR_CONST_START)
{
parser_stack_push_uint8 (context_p, SCAN_STACK_FOR_BLOCK_END);
parser_stack_push_uint8 (context_p, SCAN_STACK_PRIVATE_BLOCK);
}
#endif /* ENABLED (JERRY_ES2015) */
@ -2027,8 +2036,13 @@ scanner_scan_statement_end (parser_context_t *context_p, /**< context */
if (type == LEXER_KEYW_ELSE
&& (terminator_found || (context_p->token.flags & LEXER_WAS_NEWLINE)))
{
#if ENABLED (JERRY_ES2015)
scanner_check_function_after_if (context_p, scanner_context_p);
return SCAN_KEEP_TOKEN;
#else /* !ENABLED (JERRY_ES2015) */
scanner_context_p->mode = SCAN_MODE_STATEMENT;
return SCAN_NEXT_TOKEN;
#endif /* ENABLED (JERRY_ES2015) */
}
continue;
}
@ -2075,7 +2089,7 @@ scanner_scan_statement_end (parser_context_t *context_p, /**< context */
continue;
}
#if ENABLED (JERRY_ES2015)
case SCAN_STACK_FOR_BLOCK_END:
case SCAN_STACK_PRIVATE_BLOCK:
{
parser_stack_pop_uint8 (context_p);
scanner_pop_literal_pool (context_p, scanner_context_p);

119
tests/jerry/es2015/function-if.js Normal file
View File

@ -0,0 +1,119 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
function check_syntax_error (code)
{
try {
eval (code)
assert (false)
} catch (e) {
assert (e instanceof SyntaxError)
}
}
check_syntax_error ("'use strict'; if (true) function f() {}")
check_syntax_error ("'use strict'; if (true) ; else function f() {}")
check_syntax_error ("'use strict'; a: function f() {}")
check_syntax_error ("if (true) async function f() {}")
check_syntax_error ("if (true) ; else async function f() {}")
check_syntax_error ("if (true) a: function f() {}")
check_syntax_error ("if (true) ; else a: function f() {}")
var g = 1
var h = 1
function f1(p)
{
assert(g === undefined)
assert(h === undefined)
if (p)
// Same as: { function g() { return 3 } }
function g() { return 3 }
else
// Same as: { function h() { return 4 } }
function h() { return 4 }
if (p) {
assert(g() === 3)
assert(h === undefined)
} else {
assert(g === undefined)
assert(h() === 4)
}
}
f1(true)
f1(false)
function f2()
{
assert(g() === 2)
a: b: c: d: function g() { return 2 }
assert(h === undefined)
{
assert(h() === 3)
a: b: c: d: function h() { return 3 }
}
assert(h() === 3)
try {
assert(h() === 4)
a: b: c: d: function h() { return 4 }
throw 1
} catch (e) {
assert(h() === 5)
a: b: c: d: function h() { return 5 }
} finally {
assert(h() === 6)
a: b: c: d: function h() { return 6 }
}
assert(h() === 6)
switch (1) {
default:
assert(h() === 7)
a: b: c: d: function h() { return 7 }
}
assert(h() === 7)
}
f2()
function f3()
{
assert(h === undefined)
{
let a = eval("1")
assert(a === 1)
assert(h() === 1)
a: b: c: d: function h() { return 1 }
}
assert(h() === 1)
{
eval("a: b: c: d: function h() { return 2 }")
assert(h() === 2)
}
assert(h() === 2)
}
f3()