YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement optional chaining (#5164)

Browse Source 
The work is based on PR #4843, only fixed some conflicts and cppcheck errors.

Co-authored-by: Robert Fancsik robert.fancsik@h-lab.eu
JerryScript-DCO-1.0-Signed-off-by: Gergo Csizi gergocs@inf.u-szeged.hu
This commit is contained in:
Gergo Csizi
2024-11-20 11:57:58 +01:00
committed by GitHub
parent e9f08a7879
commit f54f2d3a7b
14 changed files with 1012 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/parser/js/byte-code.c
+1 -1
View File
@@ -28,7 +28,7 @@ JERRY_STATIC_ASSERT (offsetof (cbc_uint8_arguments_t, script_value) == offsetof
* whenever new bytecodes are introduced or existing ones have been deleted.
*/
JERRY_STATIC_ASSERT (CBC_END == 238, number_of_cbc_opcodes_changed);
JERRY_STATIC_ASSERT (CBC_EXT_END == 167, number_of_cbc_ext_opcodes_changed);
JERRY_STATIC_ASSERT (CBC_EXT_END == 170, number_of_cbc_ext_opcodes_changed);
/** \addtogroup parser Parser
* @{
jerry-core/parser/js/byte-code.h
+2 -2
View File
@@ -497,9 +497,9 @@
CBC_FORWARD_BRANCH (CBC_EXT_DEFAULT_INITIALIZER, -1, VM_OC_DEFAULT_INITIALIZER) \
CBC_OPCODE (CBC_EXT_ERROR, CBC_NO_FLAG, 0, VM_OC_ERROR) \
CBC_FORWARD_BRANCH (CBC_EXT_BRANCH_IF_NULLISH, -1, VM_OC_BRANCH_IF_NULLISH) \
\
/* Basic opcodes. */ \
CBC_OPCODE (CBC_EXT_POP_REFERENCE, CBC_NO_FLAG, -2, VM_OC_POP_REFERENCE) \
CBC_FORWARD_BRANCH (CBC_EXT_BRANCH_OPTIONAL_CHAIN, 0, VM_OC_BRANCH_OPTIONAL_CHAIN) \
/* Basic opcodes. */ \
CBC_OPCODE (CBC_EXT_CREATE_ARGUMENTS, CBC_HAS_LITERAL_ARG, 0, VM_OC_CREATE_ARGUMENTS) \
CBC_OPCODE (CBC_EXT_CREATE_VAR_EVAL, CBC_HAS_LITERAL_ARG, 0, VM_OC_EXT_VAR_EVAL) \
CBC_OPCODE (CBC_EXT_CREATE_VAR_FUNC_EVAL, CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2, 0, VM_OC_EXT_VAR_EVAL) \
jerry-core/parser/js/js-lexer.c
+30
View File
@@ -381,6 +381,29 @@ lexer_skip_spaces (parser_context_t *context_p) /**< context */
}
} /* lexer_skip_spaces */
/**
* Checks the next token start character.
*
* @return LIT_INVALID_CP - if there is no more characters to read
* next byte - otherwise
*/
lit_code_point_t
lexer_peek_next_character (parser_context_t *context_p) /**< context */
{
if (!(context_p->token.flags & LEXER_NO_SKIP_SPACES))
{
lexer_skip_spaces (context_p);
context_p->token.flags = (uint8_t) (context_p->token.flags | LEXER_NO_SKIP_SPACES);
}
if (context_p->source_p < context_p->source_end_p)
{
return context_p->source_p[0];
}
return LIT_INVALID_CP;
} /* lexer_check_next_character */
/**
* Skip all the continuous empty statements.
*/
@@ -1738,6 +1761,13 @@ lexer_next_token (parser_context_t *context_p) /**< context */
length = 2;
break;
}
if (context_p->source_p[1] == (uint8_t) LIT_CHAR_DOT
&& (length < 3 || !lit_char_is_decimal_digit (context_p->source_p[2])))
{
context_p->token.type = LEXER_QUESTION_MARK_DOT;
length = 2;
break;
}
}
context_p->token.type = LEXER_QUESTION_MARK;
jerry-core/parser/js/js-lexer.h
+1
View File
@@ -154,6 +154,7 @@ typedef enum
LEXER_RIGHT_PAREN, /**< ")" */
LEXER_RIGHT_SQUARE, /**< "]" */
LEXER_DOT, /**< "." */
LEXER_QUESTION_MARK_DOT, /**< "?." */
LEXER_SEMICOLON, /**< ";" */
LEXER_COLON, /**< ":" */
LEXER_COMMA, /**< "," */
jerry-core/parser/js/js-parser-expr.c
+540 -160
View File
@@ -106,6 +106,30 @@ static const uint8_t parser_binary_precedence_table[] = {
JERRY_STATIC_ASSERT (sizeof (parser_binary_precedence_table) == 42,
parser_binary_precedence_table_should_have_39_values_in_es2015);
/**
* Call reference status flags
*/
typedef enum
{
PARSER_CALL_REFERENCE_NONE = 0, /**< no options are present */
PARSER_CALL_REFERENCE_DIRECT_EVAL = (1 << 0), /**< direct eval call */
PARSER_CALL_REFERENCE_SPREAD = (1 << 1), /**< spread call */
} parser_call_reference_flags_t;
/**
* Call reference
*/
typedef struct
{
size_t call_arguments; /**< number of call arguments */
uint16_t status_flags; /**< any combination of parser_call_reference_flags_t */
uint16_t opcode; /**< call opcode */
} parser_call_reference_t;
static void parser_parse_postfix_expresion (parser_context_t *context_p, size_t *grouping_level_p);
static parser_call_reference_t parser_form_call_reference (parser_context_t *context_p);
static bool parser_process_group_expression (parser_context_t *context_p, size_t *grouping_level_p);
/**
* Generate byte code for operators with lvalue.
*/
@@ -2354,26 +2378,10 @@ parser_parse_unary_expression (parser_context_t *context_p, /**< context */
} /* parser_parse_unary_expression */
/**
* Parse the postfix part of unary operators, and
* generate byte code for the whole expression.
* Parse expr.#property
*/
static void
parser_process_unary_expression (parser_context_t *context_p, /**< context */
size_t grouping_level) /**< grouping level */
{
/* Parse postfix part of a primary expression. */
while (true)
{
/* Since break would only break the switch, we use
* continue to continue this loop. Without continue,
* the code abandons the loop. */
switch (context_p->token.type)
{
case LEXER_DOT:
{
parser_push_result (context_p);
if (lexer_check_next_character (context_p, LIT_CHAR_HASHMARK))
parser_parse_private_property_access (parser_context_t *context_p) /**< context */
{
lexer_next_token (context_p);
@@ -2391,7 +2399,22 @@ parser_process_unary_expression (parser_context_t *context_p, /**< context */
parser_emit_cbc_ext_literal (context_p, CBC_EXT_PUSH_PRIVATE_PROP_LITERAL, context_p->lit_object.index);
lexer_next_token (context_p);
continue;
} /* parser_parse_private_property_access */
/**
* Parse expr.property
*/
static void
parser_parse_property_access (parser_context_t *context_p) /**< context */
{
JERRY_ASSERT (context_p->token.type == LEXER_DOT || context_p->token.type == LEXER_QUESTION_MARK_DOT);
parser_push_result (context_p);
if (lexer_check_next_character (context_p, LIT_CHAR_HASHMARK))
{
parser_parse_private_property_access (context_p);
return;
}
lexer_expect_identifier (context_p, LEXER_STRING_LITERAL);
@@ -2400,55 +2423,87 @@ parser_process_unary_expression (parser_context_t *context_p, /**< context */
&& context_p->lit_object.literal_p->type == LEXER_STRING_LITERAL);
context_p->token.lit_location.type = LEXER_STRING_LITERAL;
if (context_p->last_cbc_opcode == CBC_PUSH_LITERAL)
switch (context_p->last_cbc_opcode)
{
case CBC_PUSH_LITERAL:
{
JERRY_ASSERT (CBC_ARGS_EQ (CBC_PUSH_PROP_LITERAL_LITERAL, CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2));
context_p->last_cbc_opcode = CBC_PUSH_PROP_LITERAL_LITERAL;
context_p->last_cbc.value = context_p->lit_object.index;
break;
}
else if (context_p->last_cbc_opcode == CBC_PUSH_THIS)
case CBC_PUSH_THIS:
{
context_p->last_cbc_opcode = PARSER_CBC_UNAVAILABLE;
parser_emit_cbc_literal_from_token (context_p, CBC_PUSH_PROP_THIS_LITERAL);
break;
}
else if (context_p->last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER))
case PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER):
{
context_p->last_cbc_opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER_PROP_LITERAL);
context_p->last_cbc.literal_index = context_p->lit_object.index;
break;
}
else
default:
{
parser_emit_cbc_literal_from_token (context_p, CBC_PUSH_PROP_LITERAL);
break;
}
}
lexer_next_token (context_p);
continue;
}
} /* parser_parse_property_access */
case LEXER_LEFT_SQUARE:
/**
* Parse an expression enclosed with [] brackets ('[expr]')
*/
static void
parser_parse_square_bracketed_expression (parser_context_t *context_p) /**< context */
{
parser_push_result (context_p);
uint16_t last_cbc_opcode = context_p->last_cbc_opcode;
if (last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER))
{
context_p->last_cbc_opcode = PARSER_CBC_UNAVAILABLE;
}
JERRY_ASSERT (context_p->token.type == LEXER_LEFT_SQUARE);
lexer_next_token (context_p);
parser_parse_expression (context_p, PARSE_EXPR);
if (context_p->token.type != LEXER_RIGHT_SQUARE)
{
parser_raise_error (context_p, PARSER_ERR_RIGHT_SQUARE_EXPECTED);
}
lexer_next_token (context_p);
} /* parser_parser_square_bracketed_expression */
if (last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER))
/**
* Parse super[expr]
*/
static void
parser_parse_super_element_access_expression (parser_context_t *context_p) /**< context */
{
JERRY_ASSERT (context_p->last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER));
context_p->last_cbc_opcode = PARSER_CBC_UNAVAILABLE;
parser_parse_square_bracketed_expression (context_p);
parser_emit_cbc_ext (context_p, CBC_EXT_PUSH_SUPER_PROP);
continue;
} /* parser_parse_super_element_access_expression */
/**
* Parse expr[property]
*/
static void
parser_parse_element_access (parser_context_t *context_p) /**< context */
{
JERRY_ASSERT (context_p->token.type == LEXER_LEFT_SQUARE);
parser_push_result (context_p);
if (context_p->last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER))
{
parser_parse_super_element_access_expression (context_p);
return;
}
parser_parse_square_bracketed_expression (context_p);
if (PARSER_IS_MUTABLE_PUSH_LITERAL (context_p->last_cbc_opcode))
{
context_p->last_cbc_opcode = PARSER_PUSH_LITERAL_TO_PUSH_PROP_LITERAL (context_p->last_cbc_opcode);
@@ -2457,76 +2512,125 @@ parser_process_unary_expression (parser_context_t *context_p, /**< context */
{
parser_emit_cbc (context_p, CBC_PUSH_PROP);
}
continue;
}
case LEXER_TEMPLATE_LITERAL:
case LEXER_LEFT_PAREN:
{
size_t call_arguments = 0;
uint16_t opcode = CBC_CALL;
bool is_eval = false;
} /* parser_parse_element_access */
/**
* Form reference base for a call instruction
*/
static parser_call_reference_t
parser_form_call_reference (parser_context_t *context_p) /**< context */
{
parser_push_result (context_p);
parser_call_reference_t desc;
desc.status_flags = PARSER_CALL_REFERENCE_NONE;
desc.opcode = CBC_CALL;
desc.call_arguments = 0;
if (context_p->stack_top_uint8 == LEXER_KEYW_NEW)
{
if (context_p->token.type == LEXER_LEFT_PAREN)
{
parser_stack_pop_uint8 (context_p);
opcode = CBC_NEW;
}
}
else
{
if (context_p->last_cbc_opcode == CBC_PUSH_LITERAL
&& context_p->last_cbc.literal_keyword_type == LEXER_KEYW_EVAL
&& context_p->last_cbc.literal_type == LEXER_IDENT_LITERAL)
{
is_eval = true;
desc.opcode = CBC_NEW;
}
if (PARSER_IS_PUSH_PROP (context_p->last_cbc_opcode))
{
opcode = CBC_CALL_PROP;
context_p->last_cbc_opcode = PARSER_PUSH_PROP_TO_PUSH_PROP_REFERENCE (context_p->last_cbc_opcode);
return desc;
}
else if (context_p->last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER_CONSTRUCTOR))
switch (context_p->last_cbc_opcode)
{
opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_CALL);
}
else if (context_p->last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER_PROP_LITERAL))
case CBC_PUSH_LITERAL:
{
context_p->last_cbc_opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_PROP_LITERAL_REFERENCE);
opcode = CBC_CALL_PROP;
}
else if (context_p->last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER_PROP))
{
context_p->last_cbc_opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_PROP_REFERENCE);
opcode = CBC_CALL_PROP;
}
else if (context_p->last_cbc_opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_PRIVATE_PROP_LITERAL))
{
context_p->last_cbc_opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_PRIVATE_PROP_LITERAL_REFERENCE);
opcode = CBC_CALL_PROP;
}
else if (JERRY_UNLIKELY (context_p->status_flags & PARSER_INSIDE_WITH)
&& PARSER_IS_PUSH_LITERALS_WITH_THIS (context_p->last_cbc_opcode)
if (context_p->last_cbc.literal_keyword_type == LEXER_KEYW_EVAL
&& context_p->last_cbc.literal_type == LEXER_IDENT_LITERAL)
{
desc.status_flags |= PARSER_CALL_REFERENCE_DIRECT_EVAL;
}
/* FALLTHRU */
}
case CBC_PUSH_TWO_LITERALS:
case CBC_PUSH_THIS_LITERAL:
case CBC_PUSH_THREE_LITERALS:
{
JERRY_ASSERT (PARSER_IS_PUSH_LITERALS_WITH_THIS (context_p->last_cbc_opcode));
if (JERRY_UNLIKELY (context_p->status_flags & PARSER_INSIDE_WITH)
&& context_p->last_cbc.literal_type == LEXER_IDENT_LITERAL)
{
opcode = CBC_CALL_PROP;
parser_emit_ident_reference (context_p, CBC_PUSH_IDENT_REFERENCE);
parser_emit_cbc_ext (context_p, CBC_EXT_RESOLVE_BASE);
break;
}
return desc;
}
case CBC_PUSH_PROP:
case CBC_PUSH_PROP_LITERAL:
case CBC_PUSH_PROP_LITERAL_LITERAL:
case CBC_PUSH_PROP_THIS_LITERAL:
{
JERRY_ASSERT (PARSER_IS_PUSH_PROP (context_p->last_cbc_opcode));
context_p->last_cbc_opcode = PARSER_PUSH_PROP_TO_PUSH_PROP_REFERENCE (context_p->last_cbc_opcode);
break;
}
case PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER_CONSTRUCTOR):
{
desc.opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_CALL);
return desc;
}
case PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER_PROP_LITERAL):
{
context_p->last_cbc_opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_PROP_LITERAL_REFERENCE);
break;
}
case PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_SUPER_PROP):
{
context_p->last_cbc_opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_PROP_REFERENCE);
break;
}
case PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_PRIVATE_PROP_LITERAL):
{
context_p->last_cbc_opcode = PARSER_TO_EXT_OPCODE (CBC_EXT_PUSH_PRIVATE_PROP_LITERAL_REFERENCE);
break;
}
default:
{
return desc;
}
}
bool has_spread_element = false;
desc.opcode = CBC_CALL_PROP;
return desc;
} /* parser_form_call_reference */
/**
* Expect the closing left parenthesis of a call expression
*/
static inline void
parser_expect_arguments_list_end (parser_context_t *context_p) /**< context */
{
if (context_p->token.type != LEXER_RIGHT_PAREN)
{
parser_raise_error (context_p, PARSER_ERR_RIGHT_PAREN_EXPECTED);
}
} /* parser_expect_arguments_list_end */
/**
* Parse arguments list of a call expression
*/
static void
parser_process_call_arguments (parser_context_t *context_p, /**< context */
parser_call_reference_t *call_ref_p) /**< call reference */
{
if (context_p->token.type == LEXER_TEMPLATE_LITERAL)
{
call_arguments = parser_parse_tagged_template_literal (context_p);
call_ref_p->call_arguments = (uint16_t) parser_parse_tagged_template_literal (context_p);
return;
}
else
{
uint32_t call_arguments = 0;
lexer_next_token (context_p);
while (context_p->token.type != LEXER_RIGHT_PAREN)
@@ -2538,7 +2642,7 @@ parser_process_unary_expression (parser_context_t *context_p, /**< context */
if (context_p->token.type == LEXER_THREE_DOTS)
{
has_spread_element = true;
call_ref_p->status_flags |= PARSER_CALL_REFERENCE_SPREAD;
call_arguments++;
parser_emit_cbc_ext (context_p, CBC_EXT_PUSH_SPREAD_ELEMENT);
lexer_next_token (context_p);
@@ -2552,18 +2656,19 @@ parser_process_unary_expression (parser_context_t *context_p, /**< context */
continue;
}
if (context_p->token.type != LEXER_RIGHT_PAREN)
{
parser_raise_error (context_p, PARSER_ERR_RIGHT_PAREN_EXPECTED);
}
parser_expect_arguments_list_end (context_p);
break;
}
}
lexer_next_token (context_p);
JERRY_ASSERT (context_p->token.type == LEXER_RIGHT_PAREN);
call_ref_p->call_arguments = call_arguments;
} /* parser_process_call_arguments */
if (is_eval)
/**
* Save local options flags for direct eval
*/
static void
parser_prepare_direct_eval_call (parser_context_t *context_p) /**< context */
{
context_p->status_flags |= PARSER_LEXICAL_ENV_NEEDED;
@@ -2589,99 +2694,308 @@ parser_process_unary_expression (parser_context_t *context_p, /**< context */
{
parser_emit_cbc (context_p, CBC_EVAL);
}
} /* parser_prepare_direct_eval_call */
/**
* Emit bytecode for spread call
*/
static void
parser_emit_spread_call (parser_context_t *context_p, /**< context */
parser_call_reference_t *call_ref_p) /**< call reference */
{
uint16_t call_opcode;
switch (call_ref_p->opcode)
{
case CBC_CALL:
{
call_opcode = CBC_EXT_SPREAD_CALL;
break;
}
case CBC_CALL_PROP:
{
call_opcode = CBC_EXT_SPREAD_CALL_PROP;
break;
}
case CBC_NEW:
{
call_opcode = CBC_EXT_SPREAD_NEW;
break;
}
case PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_CALL):
{
call_opcode = CBC_EXT_SPREAD_SUPER_CALL;
break;
}
default:
{
JERRY_UNREACHABLE ();
}
}
if (has_spread_element)
{
uint16_t spread_opcode;
parser_emit_cbc_ext_call (context_p, call_opcode, call_ref_p->call_arguments);
} /* parser_emit_spread_call */
if (opcode == CBC_CALL)
/**
* Emit call opcode with 0 or 1 argument
*/
static void
parser_emit_call_01 (parser_context_t *context_p, /**< context */
parser_call_reference_t *call_ref_p) /**< call reference */
{
spread_opcode = CBC_EXT_SPREAD_CALL;
}
else if (opcode == CBC_CALL_PROP)
{
spread_opcode = CBC_EXT_SPREAD_CALL_PROP;
}
else if (opcode == CBC_NEW)
{
spread_opcode = CBC_EXT_SPREAD_NEW;
}
else
{
/* opcode is unchanged */
JERRY_ASSERT (opcode == PARSER_TO_EXT_OPCODE (CBC_EXT_SUPER_CALL));
spread_opcode = CBC_EXT_SPREAD_SUPER_CALL;
}
JERRY_ASSERT (call_ref_p->call_arguments <= 1);
parser_emit_cbc_ext_call (context_p, spread_opcode, call_arguments);
continue;
switch (call_ref_p->opcode)
{
case CBC_CALL:
{
parser_emit_cbc (context_p, (uint16_t) (CBC_CALL0 + (call_ref_p->call_arguments * 6)));
break;
}
case CBC_CALL_PROP:
{
parser_emit_cbc (context_p, (uint16_t) (CBC_CALL0_PROP + (call_ref_p->call_arguments * 6)));
break;
}
case CBC_NEW:
{
parser_emit_cbc (context_p, (uint16_t) (CBC_NEW0 + call_ref_p->call_arguments));
break;
}
default:
{
parser_emit_cbc_call (context_p, call_ref_p->opcode, call_ref_p->call_arguments);
break;
}
}
} /* parser_emit_call_01 */
if (call_arguments <= 1)
/**
* Emit call opcode with 2 arguments
*/
static void
parser_emit_call_2 (parser_context_t *context_p, /**< context */
parser_call_reference_t *call_ref_p) /**< call reference */
{
if (opcode == CBC_CALL)
JERRY_ASSERT (call_ref_p->call_arguments == 2);
switch (call_ref_p->opcode)
{
parser_emit_cbc (context_p, (uint16_t) (CBC_CALL0 + (call_arguments * 6)));
continue;
}
if (opcode == CBC_CALL_PROP)
{
parser_emit_cbc (context_p, (uint16_t) (CBC_CALL0_PROP + (call_arguments * 6)));
continue;
}
if (opcode == CBC_NEW)
{
parser_emit_cbc (context_p, (uint16_t) (CBC_NEW0 + call_arguments));
continue;
}
}
else if (call_arguments == 2)
{
if (opcode == CBC_CALL)
case CBC_CALL:
{
parser_emit_cbc (context_p, CBC_CALL2);
continue;
break;
}
if (opcode == CBC_CALL_PROP)
case CBC_CALL_PROP:
{
parser_flush_cbc (context_p);
/* Manually adjusting stack usage. */
JERRY_ASSERT (context_p->stack_depth > 0);
context_p->stack_depth--;
parser_emit_cbc (context_p, CBC_CALL2_PROP);
continue;
}
}
parser_emit_cbc_call (context_p, opcode, call_arguments);
continue;
break;
}
default:
{
if (context_p->stack_top_uint8 == LEXER_KEYW_NEW)
parser_emit_cbc_call (context_p, call_ref_p->opcode, call_ref_p->call_arguments);
break;
}
}
} /* parser_emit_call_2 */
/**
* Parse expr(arguments) or expr`template literal`
*/
static void
parser_parse_call_expression (parser_context_t *context_p, /**< context */
parser_call_reference_t *call_ref_p) /**< call reference */
{
JERRY_ASSERT (context_p->token.type == LEXER_LEFT_PAREN || context_p->token.type == LEXER_TEMPLATE_LITERAL);
parser_process_call_arguments (context_p, call_ref_p);
lexer_next_token (context_p);
if (call_ref_p->status_flags & PARSER_CALL_REFERENCE_DIRECT_EVAL)
{
parser_prepare_direct_eval_call (context_p);
}
if (call_ref_p->status_flags & PARSER_CALL_REFERENCE_SPREAD)
{
parser_emit_spread_call (context_p, call_ref_p);
return;
}
if (call_ref_p->call_arguments <= 1)
{
parser_emit_call_01 (context_p, call_ref_p);
}
else if (call_ref_p->call_arguments == 2)
{
parser_emit_call_2 (context_p, call_ref_p);
}
else
{
parser_emit_cbc_call (context_p, call_ref_p->opcode, call_ref_p->call_arguments);
}
} /* parser_parse_call_expression */
/**
* Process 'expr?.'
*/
static void
parser_parse_optional_chain (parser_context_t *context_p, /**< context */
size_t *grouping_level_p) /**< grouping level */
{
JERRY_ASSERT (context_p->token.type == LEXER_QUESTION_MARK_DOT);
parser_push_result (context_p);
parser_branch_t branch;
switch (lexer_peek_next_character (context_p))
{
case LIT_CHAR_GRAVE_ACCENT:
{
parser_raise_error (context_p, PARSER_ERR_INVALID_TAGGED_TEMPLATE_OPTIONAL_CHAIN);
break;
}
case LIT_CHAR_LEFT_PAREN:
{
lexer_next_token (context_p);
parser_call_reference_t call_ref = parser_form_call_reference (context_p);
parser_emit_cbc_ext_forward_branch (context_p, CBC_EXT_BRANCH_OPTIONAL_CHAIN, &branch);
if (call_ref.opcode == CBC_CALL_PROP)
{
parser_emit_cbc_ext (context_p, CBC_EXT_POP_REFERENCE);
parser_flush_cbc (context_p);
JERRY_ASSERT (context_p->stack_limit - context_p->stack_depth >= 2);
PARSER_PLUS_EQUAL_U16 (context_p->stack_depth, 2);
}
parser_parse_call_expression (context_p, &call_ref);
break;
}
case LIT_CHAR_LEFT_SQUARE:
{
parser_emit_cbc_ext_forward_branch (context_p, CBC_EXT_BRANCH_OPTIONAL_CHAIN, &branch);
lexer_next_token (context_p);
parser_parse_square_bracketed_expression (context_p);
parser_emit_cbc (context_p, CBC_PUSH_PROP);
break;
}
default:
{
parser_emit_cbc_ext_forward_branch (context_p, CBC_EXT_BRANCH_OPTIONAL_CHAIN, &branch);
parser_parse_property_access (context_p);
break;
}
}
while (true)
{
switch (context_p->token.type)
{
case LEXER_TEMPLATE_LITERAL:
case LEXER_INCREASE:
case LEXER_DECREASE:
{
parser_raise_error (context_p, PARSER_ERR_INVALID_TAGGED_TEMPLATE_OPTIONAL_CHAIN);
break;
}
case LEXER_DOT:
case LEXER_LEFT_PAREN:
case LEXER_LEFT_SQUARE:
case LEXER_QUESTION_MARK_DOT:
{
size_t grouping_level = *grouping_level_p | PARSE_EXPR_LEFT_HAND_SIDE;
parser_parse_postfix_expresion (context_p, &grouping_level);
break;
}
case LEXER_RIGHT_PAREN:
{
if (parser_process_group_expression (context_p, grouping_level_p))
{
continue;
}
break;
}
default:
{
break;
}
}
break;
}
parser_push_result (context_p);
parser_set_branch_to_current_position (context_p, &branch);
if (LEXER_IS_BINARY_LVALUE_OP_TOKEN (context_p->token.type))
{
parser_raise_error (context_p, PARSER_ERR_INVALID_LHS_ASSIGNMENT);
}
} /* parser_parse_optional_chain */
/**
* Process 'new expr'
*/
static void
parser_process_new_expression (parser_context_t *context_p) /**< context */
{
JERRY_ASSERT (context_p->stack_top_uint8 == LEXER_KEYW_NEW);
parser_push_result (context_p);
parser_emit_cbc (context_p, CBC_NEW0);
parser_stack_pop_uint8 (context_p);
continue;
}
} /* parser_process_new_expression */
if (!(context_p->token.flags & LEXER_WAS_NEWLINE)
&& (context_p->token.type == LEXER_INCREASE || context_p->token.type == LEXER_DECREASE)
&& grouping_level != PARSE_EXPR_LEFT_HAND_SIDE)
/**
* Process postfix unary lvalue operators (++, --)
*/
static void
parser_parse_postfix_lvalue (parser_context_t *context_p, /**< context */
size_t grouping_level) /**< grouping level */
{
cbc_opcode_t opcode = (context_p->token.type == LEXER_INCREASE) ? CBC_POST_INCR : CBC_POST_DECR;
parser_push_result (context_p);
parser_emit_unary_lvalue_opcode (context_p, opcode);
lexer_next_token (context_p);
}
break;
}
}
break;
if ((context_p->token.flags & LEXER_WAS_NEWLINE) || grouping_level == PARSE_EXPR_LEFT_HAND_SIDE)
{
return;
}
switch (context_p->token.type)
{
case LEXER_INCREASE:
{
parser_push_result (context_p);
parser_emit_unary_lvalue_opcode (context_p, CBC_POST_INCR);
break;
}
case LEXER_DECREASE:
{
parser_push_result (context_p);
parser_emit_unary_lvalue_opcode (context_p, CBC_POST_DECR);
break;
}
default:
{
return;
}
}
lexer_next_token (context_p);
} /* parser_parse_postfix_lvalue */
/**
* Emit bytecode for prefix unary tokes
*/
static void
parser_process_prefix_unary_opcodes (parser_context_t *context_p) /**< context */
{
uint8_t last_unary_token = LEXER_INCREASE;
/* Generate byte code for the unary operators. */
@@ -2753,7 +3067,60 @@ parser_process_unary_expression (parser_context_t *context_p, /**< context */
}
}
}
} /* parser_process_unary_expression */
} /* parser_process_prefix_unary_opcodes */
/**
* Parse the postfix part of the expression
*/
static void
parser_parse_postfix_expresion (parser_context_t *context_p, /**< context */
size_t *grouping_level_p) /**< grouping level */
{
/* Parse postfix part of a primary expression. */
while (true)
{
/* Since break would only break the switch, we use
* continue to continue this loop. Without continue,
* the code abandons the loop. */
switch (context_p->token.type)
{
case LEXER_DOT:
{
parser_parse_property_access (context_p);
continue;
}
case LEXER_LEFT_SQUARE:
{
parser_parse_element_access (context_p);
continue;
}
case LEXER_QUESTION_MARK_DOT:
{
parser_parse_optional_chain (context_p, grouping_level_p);
continue;
}
case LEXER_TEMPLATE_LITERAL:
case LEXER_LEFT_PAREN:
{
parser_call_reference_t call_ref = parser_form_call_reference (context_p);
parser_parse_call_expression (context_p, &call_ref);
continue;
}
default:
{
if (context_p->stack_top_uint8 == LEXER_KEYW_NEW)
{
parser_process_new_expression (context_p);
continue;
}
parser_parse_postfix_lvalue (context_p, *grouping_level_p);
break;
}
}
break;
}
} /* parser_parse_postfix_expresion */
/**
* Append a binary '=' token.
@@ -2947,8 +3314,8 @@ parser_check_invalid_logical_op (parser_context_t *context_p, /**< context */
*/
static void
parser_append_binary_lvalue_token (parser_context_t *context_p, /**< context */
bool is_logical_assignment) /**< true - if form logical assignment reference
* false - otherwise */
bool is_logical_assignment) /**< true - if form logical assignment
* reference false - otherwise */
{
if (PARSER_IS_PUSH_LITERALS_WITH_THIS (context_p->last_cbc_opcode)
&& context_p->last_cbc.literal_type == LEXER_IDENT_LITERAL)
@@ -3375,6 +3742,11 @@ parser_pattern_get_target (parser_context_t *context_p, /**< context */
parser_pattern_flags_t flags) /**< flags */
{
parser_pattern_end_marker_t end_marker;
scanner_location_t location;
location.column = 0;
location.line = 0;
location.source_p = NULL;
end_marker.location = location;
end_marker.token.type = LEXER_INVALID_PATTERN;
parser_branch_t skip_init;
@@ -4029,10 +4401,16 @@ parser_process_expression_sequence (parser_context_t *context_p) /**< context */
/**
* Process group expression.
*/
static void
static bool
parser_process_group_expression (parser_context_t *context_p, /**< context */
size_t *grouping_level_p) /**< grouping level */
{
if (context_p->token.type != LEXER_RIGHT_PAREN
|| (context_p->stack_top_uint8 != LEXER_LEFT_PAREN && context_p->stack_top_uint8 != LEXER_COMMA_SEP_LIST))
{
return false;
}
JERRY_ASSERT (*grouping_level_p >= PARSER_GROUPING_LEVEL_INCREASE);
(*grouping_level_p) -= PARSER_GROUPING_LEVEL_INCREASE;
@@ -4056,6 +4434,7 @@ parser_process_group_expression (parser_context_t *context_p, /**< context */
{
parser_stack_push_uint8 (context_p, LEXER_ASSIGN_GROUP_EXPR);
}
return true;
} /* parser_process_group_expression */
/**
@@ -4124,7 +4503,8 @@ parser_parse_expression (parser_context_t *context_p, /**< context */
while (true)
{
process_unary_expression:
parser_process_unary_expression (context_p, grouping_level);
parser_parse_postfix_expresion (context_p, &grouping_level);
parser_process_prefix_unary_opcodes (context_p);
if (JERRY_LIKELY (grouping_level != PARSE_EXPR_LEFT_HAND_SIDE))
{
jerry-core/parser/js/js-parser-internal.h
+1
View File
@@ -736,6 +736,7 @@ bool lexer_check_next_character (parser_context_t *context_p, lit_utf8_byte_t ch
bool lexer_check_next_characters (parser_context_t *context_p, lit_utf8_byte_t character1, lit_utf8_byte_t character2);
uint8_t lexer_consume_next_character (parser_context_t *context_p);
bool lexer_check_post_primary_exp (parser_context_t *context_p);
lit_code_point_t lexer_peek_next_character (parser_context_t *context_p);
void lexer_skip_empty_statements (parser_context_t *context_p);
bool lexer_check_arrow (parser_context_t *context_p);
bool lexer_check_arrow_param (parser_context_t *context_p);
jerry-core/parser/js/js-scanner.c
+33 -1
View File
@@ -354,6 +354,29 @@ scanner_scan_primary_expression (parser_context_t *context_p, /**< context */
return SCAN_NEXT_TOKEN;
} /* scanner_scan_primary_expression */
/**
* Consume the ?. token
*
* @return token type to continue the post primary expression parsing
*/
static lexer_token_type_t
scanner_consume_optional_chain (parser_context_t *context_p) /**< context */
{
switch (lexer_peek_next_character (context_p))
{
case LIT_CHAR_LEFT_PAREN:
case LIT_CHAR_LEFT_SQUARE:
{
lexer_next_token (context_p);
return context_p->token.type;
}
default:
{
return LEXER_DOT;
}
}
} /* scanner_consume_optional_chain */
/**
* Scan the tokens after the primary expression.
*
@@ -364,13 +387,19 @@ scanner_scan_post_primary_expression (parser_context_t *context_p, /**< context
scanner_context_t *scanner_context_p, /**< scanner context */
lexer_token_type_t type, /**< current token type */
scan_stack_modes_t stack_top) /**< current stack top */
{
while (true)
{
switch (type)
{
case LEXER_QUESTION_MARK_DOT:
{
type = scanner_consume_optional_chain (context_p);
continue;
}
case LEXER_DOT:
{
lexer_scan_identifier (context_p, LEXER_PARSE_NO_OPTS);
if (context_p->token.type == LEXER_HASHMARK)
{
context_p->token.flags |= LEXER_NO_SKIP_SPACES;
@@ -436,6 +465,9 @@ scanner_scan_post_primary_expression (parser_context_t *context_p, /**< context
}
}
break;
}
if (LEXER_IS_BINARY_OP_TOKEN (type) && (type != LEXER_KEYW_IN || !SCANNER_IS_FOR_START (stack_top)))
{
scanner_context_p->mode = SCAN_MODE_PRIMARY_EXPRESSION;
jerry-core/parser/js/parser-error-messages.inc.h
+1
View File
@@ -169,6 +169,7 @@ PARSER_ERROR_DEF (PARSER_ERR_IMPORT_META_REQUIRE_MODULE, "Cannot use 'import.met
#if JERRY_PARSER
PARSER_ERROR_DEF (PARSER_ERR_INVALID_IDENTIFIER_PART, "Character cannot be part of an identifier")
PARSER_ERROR_DEF (PARSER_ERR_EVAL_CANNOT_ASSIGNED, "Eval cannot be assigned to in strict mode")
PARSER_ERROR_DEF (PARSER_ERR_INVALID_TAGGED_TEMPLATE_OPTIONAL_CHAIN, "Invalid tagged template on optional chain")
PARSER_ERROR_DEF (PARSER_ERR_WITH_NOT_ALLOWED, "With statement not allowed in strict mode")
PARSER_ERROR_DEF (PARSER_ERR_NEW_TARGET_NOT_ALLOWED, "new.target expression is not allowed here")
PARSER_ERROR_DEF (PARSER_ERR_INVALID_IDENTIFIER_START, "Character cannot be start of an identifier")
jerry-core/parser/js/parser-error-messages.ini
+1
View File
@@ -140,3 +140,4 @@ PARSER_ERR_UNDECLARED_PRIVATE_FIELD = "Private field must be declared in an encl
PARSER_ERR_DELETE_PRIVATE_FIELD = "Private fields can not be deleted"
PARSER_ERR_UNEXPECTED_PRIVATE_FIELD = "Unexpected private field"
PARSER_ERR_CLASS_PRIVATE_CONSTRUCTOR = "Class constructor may not be a private method"
PARSER_ERR_INVALID_TAGGED_TEMPLATE_OPTIONAL_CHAIN = "Invalid tagged template on optional chain"
jerry-core/vm/vm.c
+25 -3
View File
@@ -3174,9 +3174,6 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
case VM_OC_EVAL:
{
JERRY_CONTEXT (status_flags) |= ECMA_STATUS_DIRECT_EVAL;
JERRY_ASSERT ((*byte_code_p >= CBC_CALL && *byte_code_p <= CBC_CALL2_PROP_BLOCK)
|| (*byte_code_p == CBC_EXT_OPCODE && byte_code_p[1] >= CBC_EXT_SPREAD_CALL
&& byte_code_p[1] <= CBC_EXT_SPREAD_CALL_PROP_BLOCK));
continue;
}
case VM_OC_CALL:
@@ -3307,6 +3304,31 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
ecma_fast_free_value (value);
continue;
}
case VM_OC_BRANCH_OPTIONAL_CHAIN:
{
left_value = stack_top_p[-1];
bool pop_reference = byte_code_p[0] == CBC_EXT_OPCODE && byte_code_p[1] == CBC_EXT_POP_REFERENCE;
if (!(ecma_is_value_null (left_value) || ecma_is_value_undefined (left_value)))
{
if (pop_reference)
{
byte_code_p += 2;
}
continue;
}
stack_top_p[-1] = ECMA_VALUE_UNDEFINED;
byte_code_p = byte_code_start_p + branch_offset;
if (!pop_reference)
{
continue;
}
/* FALLTHRU */
}
case VM_OC_POP_REFERENCE:
{
ecma_free_value (stack_top_p[-2]);
jerry-core/vm/vm.h
+1
View File
@@ -165,6 +165,7 @@ typedef enum
VM_OC_JUMP, /**< jump */
VM_OC_BRANCH_IF_NULLISH, /** branch if undefined or null */
VM_OC_BRANCH_OPTIONAL_CHAIN, /** branch if undefined or null and adjust stack */
VM_OC_POP_REFERENCE, /** prop identifier or property reference from the stack */
VM_OC_BRANCH_IF_STRICT_EQUAL, /**< branch if strict equal */
tests/jerry/es.next/optional-chaining.js
+167
View File
@@ -0,0 +1,167 @@
// 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 expectSyntaxError(str) {
try {
eval(str);
assert(false);
} catch (e) {
assert(e instanceof SyntaxError);
}
}
function expectTypeError(cb) {
try {
cb();
assert(false);
} catch (e) {
assert(e instanceof TypeError);
}
}
expectSyntaxError("this?.a``");
expectSyntaxError("this?.['a']``");
expectSyntaxError("this?.``");
expectSyntaxError("this.a?.``");
expectSyntaxError("this['a']?.``");
expectSyntaxError("this?.a = 9");
expectSyntaxError("this.a.a.a.a.a?.a = 9");
expectSyntaxError("this?.a.a.a.a.a.a = 9");
expectSyntaxError("this?.a++");
expectSyntaxError("this?.a.a.a.a.a.a++");
expectSyntaxError("this.a.a.a.a.?a.a++");
expectSyntaxError("this?.a--");
expectSyntaxError("this?.a.a.a.a.a.a--");
expectSyntaxError("this.a.a.a.a.?a.a--");
var o = {
a: 4.1,
b() {
return 4.2;
},
c: {
a: 4.3,
b() {
return 4.4
}
},
e(...args) {
return args.reduce((p, c) => p + c);
}
}
assert(o?.a === 4.1);
assert(o?.a2 === undefined);
assert(this.o?.a === 4.1);
assert(this.o?.a2 === undefined);
assert(this.o?.['a'] === 4.1);
assert(this.o?.['a2'] === undefined);
assert(typeof o?.a === 'number');
assert(typeof o?.a2 === 'undefined');
assert(o?.c?.a === 4.3);
assert(o?.c?.a2 === undefined);
assert(this.o?.c?.a === 4.3);
assert(this.o?.c?.a2 === undefined);
assert(this.o?.c?.['a'] === 4.3);
assert(this.o?.c?.['a2'] === undefined);
assert(typeof o?.c?.a === 'number');
assert(typeof o?.c?.a2 === 'undefined');
assert(o?.d === undefined);
assert(o?.d?.d === undefined);
assert(o?.d?.d?.['d'] === undefined);
assert(o?.b?.() === 4.2);
assert(o?.b2?.() === undefined);
assert(o?.c?.b?.() === 4.4);
assert(o?.c?.b2?.() === undefined);
assert(o?.e(...[1.25, 2.25, 3.25]) === 6.75);
assert(o?.e(...[1.25, 2.25, 3.25], ...[0.25]) === 7);
assert(o?.['e'](...[1.25, 2.25, 3.25]) === 6.75);
assert(o?.['e'](...[1.25, 2.25, 3.25], ...[0.25]) === 7);
assert(o?.e?.(...[1.25, 2.25, 3.25]) === 6.75);
assert(o?.e?.(...[1.25, 2.25, 3.25], ...[0.25]) === 7);
assert(o?.['e']?.(...[1.25, 2.25, 3.25]) === 6.75);
assert(o?.['e']?.(...[1.25, 2.25, 3.25], ...[0.25]) === 7);
// Test short circuit
let count = 0;
assert(undefined?.[count++] === undefined);
assert(undefined?.[count++]() === undefined);
assert(undefined?.[count++]()() === undefined);
assert(null?.[count++] === undefined);
assert(null?.[count++]() === undefined);
assert(null?.[count++]()() === undefined);
assert(count === 0);
// Test optional call
var g = undefined;
function f () {
return 4.5;
}
assert(g?.() === undefined);
assert(this?.g?.() === undefined);
assert(this.g?.() === undefined);
expectTypeError(_ => {
this.g();
});
assert(f?.() === 4.5);
assert(this?.f?.() === 4.5);
assert(this.f?.() === 4.5);
assert(f() === 4.5);
// test direct eval
var a = 5.1;
eval('a = 5.2');
assert(a === 5.2);
eval?.('a = 5.3');
assert(a === 5.3);
eval?.(...['a = 5.4']);
assert(a === 5.4);
const saved_eval = eval;
eval = undefined;
eval?.('a = 5.5')
assert(a === 5.4);
eval?.(...['a = 5.5'])
assert(a === 5.4);
eval = saved_eval;
// test optional private property access
class A {
#a = 5.1;
test(o) {
return o?.#a;
}
}
let instance = new A;
assert(instance.test(instance) === 5.1);
assert(instance.test(undefined) === undefined);
assert(instance.test(null) === undefined);
expectTypeError(_ => {
instance.test({});
});
tests/test262-excludelist.xml
-35
View File
@@ -2003,16 +2003,12 @@
<test id="language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next.js"><reason></reason></test>
<test id="language/expressions/class/elements/class-name-static-initializer-anonymous.js"><reason></reason></test>
<test id="language/expressions/class/elements/class-name-static-initializer-default-export.js"><reason></reason></test>
<test id="language/expressions/class/elements/grammar-private-field-optional-chaining.js"><reason></reason></test>
<test id="language/expressions/class/elements/private-field-after-optional-chain.js"><reason></reason></test>
<test id="language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js"><reason></reason></test>
<test id="language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js"><reason></reason></test>
<test id="language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next.js"><reason></reason></test>
<test id="language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js"><reason></reason></test>
<test id="language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js"><reason></reason></test>
<test id="language/statements/class/elements/async-gen-private-method/yield-promise-reject-next.js"><reason></reason></test>
<test id="language/statements/class/elements/grammar-private-field-optional-chaining.js"><reason></reason></test>
<test id="language/statements/class/elements/private-field-after-optional-chain.js"><reason></reason></test>
<!-- END - ESNext stage 3 proposals: class fields, private methods and static class features -->
<!-- ESNext stage 3 proposal: top level await
@@ -2512,37 +2508,6 @@
<test id="language/statements/while/tco-body.js"><reason></reason></test>
<!-- END - ES2015: Proper Tail Call (PTC) Optimization -->
<!-- ES2020: Optional Chaining
features: [optional-chaining]
https://github.com/tc39/proposal-optional-chaining
-->
<test id="language/expressions/optional-chaining/call-expression.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/eval-optional-call.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/iteration-statement-do.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/iteration-statement-for-await-of.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/iteration-statement-for-in.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/iteration-statement-for-of-type-error.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/iteration-statement-for.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/iteration-statement-while.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/member-expression-async-identifier.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/member-expression-async-literal.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/member-expression-async-this.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/member-expression.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/new-target-optional-call.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-call-preserves-this.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-chain-async-optional-chain-square-brackets.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-chain-async-square-brackets.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-chain-expression-optional-expression.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-chain-prod-arguments.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-chain-prod-expression.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-chain-prod-identifiername.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-chain.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/optional-expression.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/runtime-semantics-evaluation.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/short-circuiting.js"><reason></reason></test>
<test id="language/expressions/optional-chaining/super-property-optional-call.js"><reason></reason></test>
<!-- END - ES2020: Optional Chaining -->
<!-- ES2017: Shared Memory and Atomics
features: [Atomics]
https://github.com/tc39/ecmascript_sharedmem
tools/cppcheck/suppressions-list
-1
View File
@@ -31,7 +31,6 @@ shiftNegativeLHS:jerry-math/*.c
shiftTooManyBits:jerry-core/*.c
shiftTooManyBitsSigned:jerry-math/*.c
signConversionCond:jerry-core/*.c
uninitvar:jerry-core/parser/js/js-parser-expr.c:3423
uninitvar:tests/unit-core/test-api-objecttype.c:119
unmatchedSuppression:jerry-core/*.inc.h
unreadVariable:jerry-core/*.c