Add support for new.target (#3469)

Notable changes:
* Extracted the pure JS/builtin and external C method invocations
  into two new methods (`ecma_op_function_call_{simple, external}`).
* Updated parser/scanner to handle "new.target" correctly.
* Added JS test case.

JerryScript-DCO-1.0-Signed-off-by: Peter Gal pgal.u-szeged@partner.samsung.com

tests/jerry/es2015/new-target-async.js

@@ -0,0 +1,20 @@
+/* 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.
+ */
+
+async function async_method () {
+    assert (new.target === undefined);
+}
+
+async_method ();

tests/jerry/es2015/new-target-class.js

@@ -0,0 +1,63 @@
+/* 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.
+ */
+
+class Simple {
+  constructor () {
+    assert (new.target === Simple);
+    this.called = 0;
+  }
+
+  get getter () {
+    this.called++;
+    return new.target;
+  }
+
+  set setter (val) {
+    assert (new.target === undefined);
+    this.called++;
+  }
+}
+
+var smp = new Simple ();
+assert (smp.getter === undefined);
+assert (smp.called === 1);
+smp.setter = -1;
+assert (smp.called === 2);
+
+class BaseA {
+  constructor () {
+    assert (new.target === SubA);
+  }
+}
+
+class SubA extends BaseA {
+  constructor () {
+    super ();
+    assert (new.target === SubA);
+  }
+}
+
+new SubA ();
+
+/* TODO: enable if there is class name support. */
+/*
+class Named {
+  constructor () {
+    assert(new.target.name == "Named");
+  }
+}
+
+new Named ();
+*/

tests/jerry/es2015/new-target-generator.js

@@ -0,0 +1,33 @@
+/* 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 *demo_gen () {
+    for (var idx = 0; idx < 3; idx++)
+    {
+      assert (new.target === undefined);
+      yield idx;
+      assert (new.target === undefined);
+    }
+}
+
+var gen = demo_gen ();
+
+var value = 0;
+for (var item of gen)
+{
+  value = item;
+}
+
+assert (value === 2);

tests/jerry/es2015/new-target.js

@@ -0,0 +1,137 @@
+/* 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 null_target () {
+  assert (new.target === undefined);
+}
+
+function demo () {
+  null_target ();
+  return new.target;
+}
+
+assert (demo () === undefined);
+assert ((new demo ()) === demo);
+
+/* new.target is only valid inside functions */
+try {
+  eval ("new.target");
+  assert (false);
+} catch (ex) {
+  assert (ex instanceof SyntaxError);
+}
+
+try {
+  var eval_other = eval;
+  eval_other ("new.target");
+  assert (false);
+} catch (ex) {
+  assert (ex instanceof SyntaxError);
+}
+
+/* test with arrow function */
+var arrow_called = false;
+function arrow () {
+    assert (new.target === arrow);
+    var mth = () => { return new.target; }
+    assert (mth () === arrow);
+    arrow_called = true;
+}
+
+new arrow ();
+assert (arrow_called === true);
+
+/* test unary operation */
+var f_called = false;
+function f () {
+  assert (isNaN (-new.target));
+  f_called = true;
+}
+
+new f ();
+assert (f_called === true);
+
+/* test property access */
+function fg (callback_object) {
+  callback_object.value = new.target.value;
+}
+
+fg.value = 22;
+
+var test_obj = {};
+new fg (test_obj);
+
+assert (test_obj.value === 22);
+
+
+/* test new.target with eval */
+function eval_test () {
+  var target = eval ("new.target");
+  assert (target === eval_test);
+}
+
+new eval_test ();
+
+function eval_eval_test () {
+  var target = eval ('eval("new.target")');
+  assert (target === eval_eval_test);
+}
+
+new eval_eval_test ();
+
+
+/* test assignment of the "new.target" */
+function expect_syntax_error (src)
+{
+  try {
+    eval (src);
+    assert (false);
+  } catch (ex) {
+    assert (ex instanceof SyntaxError);
+  }
+}
+
+expect_syntax_error ("function assign () { new.target = 3; }");
+expect_syntax_error ("function assign () { new.target += 3; }");
+expect_syntax_error ("function assign () { new.target *= 3; }");
+expect_syntax_error ("function assign () { new.target -= 3; }");
+expect_syntax_error ("function assign () { new.target |= 3; }");
+expect_syntax_error ("function assign () { new.target &= 3; }");
+
+expect_syntax_error ("function assign () { new.target++; }");
+expect_syntax_error ("function assign () { ++new.target; }");
+expect_syntax_error ("function assign () { new.target--; }");
+expect_syntax_error ("function assign () { --new.target; }");
+
+expect_syntax_error ("function synt () { new....target; }");
+
+function delete_test () {
+  assert ((delete new.target) === true);
+}
+
+new delete_test ();
+
+function binary_test_1 () {
+    /*/ new.target is converted to string */
+    assert ((new.target + 1) === "function(){/* ecmascript */}1");
+}
+function binary_test_2 () { assert (isNaN (new.target - 3)); }
+function binary_test_3 () { assert (isNaN (new.target * 2)); }
+function binary_test_4 () { assert (isNaN (new.target / 4)); }
+
+new binary_test_1 ();
+new binary_test_2 ();
+new binary_test_3 ();
+new binary_test_4 ();

tests/unit-core/test-newtarget.c

@@ -0,0 +1,223 @@
+/* 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.
+ */
+
+#include "jerryscript.h"
+#include "jerryscript-port.h"
+#include "jerryscript-port-default.h"
+#include "test-common.h"
+
+/**
+ * Register a JavaScript function in the global object.
+ */
+static jerry_value_t
+register_js_function (const char *name_p, /**< name of the function */
+                      jerry_external_handler_t handler_p) /**< function callback */
+{
+  jerry_value_t global_obj_val = jerry_get_global_object ();
+
+  jerry_value_t function_val = jerry_create_external_function (handler_p);
+  jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) name_p);
+  jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
+
+  jerry_release_value (function_name_val);
+  jerry_release_value (global_obj_val);
+
+  jerry_release_value (result_val);
+
+  return function_val;
+} /* register_js_function */
+
+enum
+{
+  TEST_ID_SIMPLE_CONSTRUCT = 1,
+  TEST_ID_SIMPLE_CALL = 2,
+  TEST_ID_CONSTRUCT_AND_CALL_SUB = 3,
+};
+
+/**
+ * Helper method to access the "new.target" via an eval call.
+ */
+static jerry_value_t
+get_new_target (void)
+{
+  const char *src = "new.target";
+  return jerry_eval ((const jerry_char_t *) src, strlen (src), 0);
+} /* get_new_target */
+
+static jerry_value_t
+construct_handler (const jerry_value_t func_obj_val, /**< function object */
+                   const jerry_value_t this_val, /**< this arg */
+                   const jerry_value_t args_p[], /**< function arguments */
+                   const jerry_length_t args_cnt) /**< number of function arguments */
+{
+  JERRY_UNUSED (func_obj_val);
+  JERRY_UNUSED (this_val);
+  JERRY_UNUSED (args_p);
+
+  if (args_cnt != 1 || !jerry_value_is_number (args_p[0]))
+  {
+    TEST_ASSERT (0 && "Invalid arguments for demo method");
+  }
+
+  int test_id = (int) jerry_get_number_value (args_p[0]);
+
+  switch (test_id)
+  {
+    case TEST_ID_SIMPLE_CONSTRUCT:
+    {
+      /* Method was called with "new": new.target should be equal to the function object. */
+      jerry_value_t target = get_new_target ();
+      TEST_ASSERT (!jerry_value_is_undefined (target));
+      TEST_ASSERT (target == func_obj_val);
+      jerry_release_value (target);
+      break;
+    }
+    case TEST_ID_SIMPLE_CALL:
+    {
+      /* Method was called directly without "new": new.target should be equal undefined. */
+      jerry_value_t target = get_new_target ();
+      TEST_ASSERT (jerry_value_is_undefined (target));
+      TEST_ASSERT (target != func_obj_val);
+      jerry_release_value (target);
+      break;
+    }
+    case TEST_ID_CONSTRUCT_AND_CALL_SUB:
+    {
+      /* Method was called with "new": new.target should be equal to the function object. */
+      jerry_value_t target = get_new_target ();
+      TEST_ASSERT (!jerry_value_is_undefined (target));
+      TEST_ASSERT (target == func_obj_val);
+      jerry_release_value (target);
+
+      /* Calling a function should hide the old "new.target". */
+      jerry_value_t sub_arg = jerry_create_number (TEST_ID_SIMPLE_CALL);
+      jerry_value_t func_call_result = jerry_call_function (func_obj_val, this_val, &sub_arg, 1);
+      TEST_ASSERT (!jerry_value_is_error (func_call_result));
+      TEST_ASSERT (jerry_value_is_undefined (func_call_result));
+      break;
+    }
+
+    default:
+    {
+      TEST_ASSERT (0 && "Incorrect test ID");
+      break;
+    }
+  }
+
+  return jerry_create_undefined ();
+} /* construct_handler */
+
+int
+main (void)
+{
+  /* Test JERRY_FEATURE_SYMBOL feature as it is a must-have in ES2015 */
+  if (!jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL))
+  {
+    jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Skipping test, ES2015 support is disabled.\n");
+    return 0;
+  }
+
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_value_t demo_func = register_js_function ("Demo", construct_handler);
+
+  {
+    jerry_value_t test_arg = jerry_create_number (TEST_ID_SIMPLE_CONSTRUCT);
+    jerry_value_t constructed = jerry_construct_object (demo_func, &test_arg, 1);
+    TEST_ASSERT (!jerry_value_is_error (constructed));
+    TEST_ASSERT (jerry_value_is_object (constructed));
+    jerry_release_value (test_arg);
+    jerry_release_value (constructed);
+  }
+
+  {
+    jerry_value_t test_arg = jerry_create_number (TEST_ID_SIMPLE_CALL);
+    jerry_value_t this_arg = jerry_create_undefined ();
+    jerry_value_t constructed = jerry_call_function (demo_func, this_arg, &test_arg, 1);
+    TEST_ASSERT (jerry_value_is_undefined (constructed));
+    jerry_release_value (constructed);
+    jerry_release_value (constructed);
+    jerry_release_value (test_arg);
+  }
+
+  {
+    jerry_value_t test_arg = jerry_create_number (TEST_ID_CONSTRUCT_AND_CALL_SUB);
+    jerry_value_t constructed = jerry_construct_object (demo_func, &test_arg, 1);
+    TEST_ASSERT (!jerry_value_is_error (constructed));
+    TEST_ASSERT (jerry_value_is_object (constructed));
+    jerry_release_value (test_arg);
+    jerry_release_value (constructed);
+  }
+
+  {
+    static const jerry_char_t test_source[] = TEST_STRING_LITERAL ("new Demo (1)");
+
+    jerry_value_t parsed_code_val = jerry_parse (NULL,
+                                                 0,
+                                                 test_source,
+                                                 sizeof (test_source) - 1,
+                                                 JERRY_PARSE_NO_OPTS);
+    TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
+
+    jerry_value_t res = jerry_run (parsed_code_val);
+    TEST_ASSERT (!jerry_value_is_error (res));
+
+    jerry_release_value (res);
+    jerry_release_value (parsed_code_val);
+  }
+
+  {
+    static const jerry_char_t test_source[] = TEST_STRING_LITERAL ("Demo (2)");
+
+    jerry_value_t parsed_code_val = jerry_parse (NULL,
+                                                 0,
+                                                 test_source,
+                                                 sizeof (test_source) - 1,
+                                                 JERRY_PARSE_NO_OPTS);
+    TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
+
+    jerry_value_t res = jerry_run (parsed_code_val);
+    TEST_ASSERT (!jerry_value_is_error (res));
+
+    jerry_release_value (res);
+    jerry_release_value (parsed_code_val);
+  }
+
+  {
+    static const jerry_char_t test_source[] = TEST_STRING_LITERAL (
+      "function base(arg) { new Demo (arg); };"
+      "base (1);"
+      "new base(1);"
+      "new base(3);"
+    );
+
+    jerry_value_t parsed_code_val = jerry_parse (NULL,
+                                                 0,
+                                                 test_source,
+                                                 sizeof (test_source) - 1,
+                                                 JERRY_PARSE_NO_OPTS);
+    TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
+
+    jerry_value_t res = jerry_run (parsed_code_val);
+    TEST_ASSERT (!jerry_value_is_error (res));
+
+    jerry_release_value (res);
+    jerry_release_value (parsed_code_val);
+  }
+
+  jerry_release_value (demo_func);
+  jerry_cleanup ();
+  return 0;
+} /* main */