[[Prototype]] object's reference count should be increased by jerry_get_prototype (#3550)

This patch ensures that the implementation satisfies the requirements of the public API documentation.

JerryScript-DCO-1.0-Signed-off-by: Robert Fancsik frobert@inf.u-szeged.hu

.travis.yml

@@ -120,11 +120,13 @@ matrix:
       script: make -f ./targets/mbedos5/Makefile.travis script
 
     - name: "Zephyr/Arduino 101 Build Test"
+      language: python # NOTE: only way to ensure python>=2.7.10 on Trusty image
+      python: 3.6
       install: make -f ./targets/zephyr/Makefile.travis install-noapt
       script: make -f ./targets/zephyr/Makefile.travis script
       addons:
         apt:
-          packages: [gperf, dfu-util, device-tree-compiler, python3-ply, python3-pip]
+          packages: [gperf, dfu-util, device-tree-compiler]
 
     - name: "NuttX/STM32F4 Build Test"
       install: make -f targets/nuttx-stm32f4/Makefile.travis install-noapt

appveyor.yml

@@ -17,20 +17,16 @@ platform:
 
 environment:
   matrix:
-    - FEATURE_DEBUGGER: ON
-    - FEATURE_DEBUGGER: OFF
+    - JERRY_DEBUGGER: ON
+    - JERRY_DEBUGGER: OFF
 
 # Steps of a job.
 init:
   - cmake -version
 before_build:
-  - if "%PLATFORM%"=="Win32" cmake -G"Visual Studio 15 2017" -Bbuild -H. -DFEATURE_DEBUGGER=%FEATURE_DEBUGGER%
-  - if "%PLATFORM%"=="x64" cmake -G"Visual Studio 15 2017 Win64" -Bbuild -H. -DFEATURE_DEBUGGER=%FEATURE_DEBUGGER%
+  - if "%PLATFORM%"=="Win32" cmake -G"Visual Studio 15 2017" -Bbuild -H. -DJERRY_DEBUGGER=%JERRY_DEBUGGER%
+  - if "%PLATFORM%"=="x64" cmake -G"Visual Studio 15 2017 Win64" -Bbuild -H. -DJERRY_DEBUGGER=%JERRY_DEBUGGER%
 build:
   project: build\Jerry.sln
   parallel: true
   verbosity: minimal
-
-artifacts:
-  - path: build\bin\$(configuration)\
-    name: JerryScriptBinary

docs/01.CONFIGURATION.md

@@ -211,6 +211,17 @@ A value of 0 will use the default value.
 | CMake:  | `-DJERRY_GC_LIMIT=(int)`                     |
 | Python: | `--gc-limit=(int)`                           |
 
+### GC mark recursion limit
+
+This option can be used to adjust the maximum recursion depth during the GC mark phase. The provided value should be an integer, which represents the allowed number of recursive calls. Increasing the depth of the recursion reduces the time of GC cycles, however increases stack usage.
+A value of 0 will prevent any recursive GC calls.
+
+| Options |                                                   |
+|---------|---------------------------------------------------|
+| C:      | `-DJERRY_GC_MARK_LIMIT=(int)`                     |
+| CMake:  | `-DJERRY_GC_MARK_LIMIT=(int)`                     |
+| Python: | `--gc-mark-limit=(int)`                           |
+
 ### Stack limit
 
 This option can be used to cap the stack usage of the engine, and prevent stack overflows due to recursion. The provided value should be an integer, which represents the allowed stack usage in kilobytes.
@@ -296,9 +307,27 @@ These files can be directly compiled with an application using the JerryScript A
 For example with the following command:
 
 ```sh
-$ gcc -Wall -o demo_app demo_app.c gen_src/jerryscript.c gen_src/jerryscript-port-default.c jerryscript-libm.c -Igen_src/ 
+$ gcc -Wall -o demo_app demo_app.c gen_src/jerryscript.c gen_src/jerryscript-port-default.c jerryscript-libm.c -Igen_src/
 ```
 
 Please note that the headers must be available on the include path.
 
 In addition there is a `-DENABLE_ALL_IN_ONE_SOURCE=ON` CMake option to use this kind of sources during the build.
+
+# Target specific information
+
+## x86 with GCC
+
+When building for Intel 32 bit architecture it is possible that GCC uses conservative options, thus assuming the most
+basic floating-point support (that is it does not generate SSE or others instructions).
+However this could lead to loss off precision and/or different results than what is required by the JavaScript standard
+in regards of floating-point values and arithmetic.
+
+To resolve this precision problem it is advised to use at least SSE2.
+To do this with GCC please provide the `-mfpmath=sse -msse2` options during build.
+
+These options can also be specified via the `build.py` script:
+
+```sh
+$ ./tools/build.py --compile-flag=-mfpmath=sse --compile-flag=-msse2 --compile-flag=-m32
+```

docs/02.API-REFERENCE.md

@@ -316,6 +316,11 @@ Enum that contains the supported binary operation types
  - JERRY_BIN_OP_GREATER - greater relation (>)
  - JERRY_BIN_OP_GREATER_EQUAL - greater or equal relation (>=)
  - JERRY_BIN_OP_INSTANCEOF - instanceof operation
+ - JERRY_BIN_OP_ADD - addition operator (+)
+ - JERRY_BIN_OP_SUB - subtraction operator (-)
+ - JERRY_BIN_OP_MUL - multiplication operator (*)
+ - JERRY_BIN_OP_DIV - division operator (/)
+ - JERRY_BIN_OP_REM - remainder operator (%)
 
 *New in version 2.0*.
 
@@ -442,7 +447,7 @@ typedef jerry_value_t (*jerry_external_handler_t) (const jerry_value_t function_
 Native free callback of an object. It is used in `jerry_object_native_info_t` and for external Array buffers.
 
 *Note*:
- - This callback method **must not** call any JerryScript API methods.
+ - Referred values by this method must have at least 1 reference. (Correct API usage satisfies this condition)
 
 **Prototype**
 
@@ -451,6 +456,7 @@ typedef void (*jerry_object_native_free_callback_t) (void *native_p);
 ```
 
 *New in version 2.0*: Renamed from `jerry_object_free_callback_t`.
+*Changed in version 2.2*: API calls are once again allowed. (See note)
 
 **See also**
 
@@ -595,6 +601,22 @@ typedef jerry_value_t (*jerry_vm_exec_stop_callback_t) (void *user_p);
 
 - [jerry_set_vm_exec_stop_callback](#jerry_set_vm_exec_stop_callback)
 
+## jerry_promise_state_t
+
+Enum which describes the state of a Promise.
+
+Possible values:
+
+ - JERRY_PROMISE_STATE_NONE - Invalid/Unknown state (possibly called on a non-promise object).
+ - JERRY_PROMISE_STATE_PENDING - Promise is in "Pending" state.
+ - JERRY_PROMISE_STATE_FULFILLED - Promise is in "Fulfilled" state.
+ - JERRY_PROMISE_STATE_REJECTED - Promise is in "Rejected" state.
+
+*New in version 2.2*.
+
+**See also**
+
+- [jerry_get_promise_result](#jerry_get_promise_result)
 
 ## jerry_typedarray_type_t
 
@@ -3231,6 +3253,144 @@ jerry_value_to_string (const jerry_value_t value);
 
 These APIs all depend on the ES2015-subset profile (or on some build options).
 
+## jerry_get_promise_result
+
+**Summary**
+
+The function returns the result of a Promise object.
+
+*Notes*:
+- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+  is no longer needed.
+- This API depends on a build option (`JERRY_ES2015_BUILTIN_PROMISE`) and can be checked
+  in runtime with the `JERRY_FEATURE_PROMISE` feature enum value,
+  see: [jerry_is_feature_enabled](#jerry_is_feature_enabled).
+- The ES2015-subset profile enables this by default.
+
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_get_promise_result (const jerry_value_t promise);
+```
+
+- `promise` - the input Promise object.
+- return
+  - The result of the Promise.
+  - If the Promise is not resolved yet the result is the 'undefined' value.
+  - A TypeError is returned if the input argument was not a Promise object or
+    the Promise support was not built into the library.
+
+*New in version 2.2*.
+
+**Example**
+
+[doctest]: # (test="compile")
+
+```c
+#include <jerryscript.h>
+
+static void
+example (void)
+{
+  // acquire/create a promise object.
+  jerry_value_t promise = jerry_create_promise ();
+  {
+    // prepare the argumnent for the resolve or reject.
+    jerry_value_t argument = jerry_create_number (33);
+
+    jerry_value_t is_ok = jerry_resolve_or_reject_promise (promise,
+                                                           argument,
+                                                           true);
+    // 'is_ok' should be checked if it is an error or not.
+    // skipped in this example
+    jerry_release_value (is_ok);
+    jerry_release_value (argument);
+  }
+
+  jerry_value_t promise_result = jerry_get_promise_result (promise);
+  // 'promise_result' is now the number 33.
+
+  jerry_release_value (promise_result);
+  jerry_release_value (promise);
+}
+```
+
+**See also**
+
+- [jerry_create_promise](#jerry_create_promise)
+- [jerry_promise_state_t](#jerry_promise_state_t)
+
+## jerry_get_promise_state
+
+**Summary**
+
+*Notes*:
+- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+  is no longer needed.
+- This API depends on a build option (`JERRY_ES2015_BUILTIN_PROMISE`) and can be checked
+  in runtime with the `JERRY_FEATURE_PROMISE` feature enum value,
+  see: [jerry_is_feature_enabled](#jerry_is_feature_enabled).
+- The ES2015-subset profile enables this by default.
+
+
+**Prototype**
+
+```c
+jerry_promise_state_t
+jerry_get_promise_state (const jerry_value_t promise);
+```
+
+- `promise` - the input promise object.
+- return
+  - [jerry_promise_state_t](#jerry_promise_state_t)
+  - `JERRY_PROMISE_STATE_NONE` is returned if the input argument was not a promise object or
+    the Promise support was not built into the library.
+
+*New in version 2.2*.
+
+**Example**
+
+[doctest]: # (test="compile")
+
+```c
+#include <jerryscript.h>
+
+static void
+example (void)
+{
+  // acquire/create a promise object.
+  jerry_value_t promise = jerry_create_promise ();
+
+  jerry_promise_state_t start_state = jerry_get_promise_state (promise);
+  // a Promise have a default state of JERRY_PROMISE_STATE_PENDING
+
+  {
+    // prepare the argumnent for the resolve or reject.
+    jerry_value_t argument = jerry_create_number (33);
+
+    jerry_value_t is_ok = jerry_resolve_or_reject_promise (promise,
+                                                           argument,
+                                                           true);
+    // 'is_ok' should be checked if it is an error or not.
+    // skipped in this example
+    jerry_release_value (is_ok);
+    jerry_release_value (argument);
+  }
+
+  jerry_promise_state_t current_state = jerry_get_promise_state (promise);
+  // at this point the Promise should be in the JERRY_PROMISE_STATE_FULFILLED state.
+
+  jerry_release_value (promise);
+}
+```
+
+**See also**
+
+- [jerry_create_promise](#jerry_create_promise)
+- [jerry_promise_state_t](#jerry_promise_state_t)
+
 ## jerry_resolve_or_reject_promise
 
 **Summary**
@@ -3548,7 +3708,7 @@ jerry_create_arraybuffer_external (const jerry_length_t size
 - `free_cb` - the callback function called when the object is released
 - return value
   - the new ArrayBuffer as a `jerry_value_t`
-  - if the `size` is zero or `buffer_p` is a null pointer will return RangeError
+  - if the `size` is zero or `buffer_p` is a null pointer this will return an empty ArrayBuffer.
 
 *New in version 2.0*.
 
@@ -4068,7 +4228,7 @@ jerry_value_t
 jerry_create_string (const jerry_char_t *str_p);
 ```
 
-- `str_p` - pointer to string
+- `str_p` - non-null pointer to string
 - return value - value of the created string
 
 **Example**
@@ -4107,7 +4267,7 @@ jerry_create_string_sz (const jerry_char_t *str_p,
                         jerry_size_t str_size)
 ```
 
-- `str_p` - pointer to string
+- `str_p` - non-null pointer to string
 - `str_size` - size of the string
 - return value - value of the created string
 
@@ -4138,8 +4298,9 @@ jerry_create_string_sz (const jerry_char_t *str_p,
 
 Create string from a valid UTF8 string.
 
-*Note*: The difference from [jerry_create_string](#jerry_create_string) is that it accepts utf-8 string instead of cesu-8 string.
-*Note*: Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+*Note*:
+ - The difference from [jerry_create_string](#jerry_create_string) is that it accepts utf-8 string instead of cesu-8 string.
+ - Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
 is no longer needed.
 
 **Prototype**
@@ -4149,7 +4310,7 @@ jerry_value_t
 jerry_create_string_from_utf8 (const jerry_char_t *str_p);
 ```
 
-- `str_p` - pointer to string
+- `str_p` - non-null pointer to string
 - return value - value of the created string
 
 *New in version 2.0*.
@@ -4179,19 +4340,20 @@ jerry_create_string_from_utf8 (const jerry_char_t *str_p);
 
 Create string from a valid UTF8 string.
 
-*Note*: The difference from [jerry_create_string_sz](#jerry_create_string_sz) is that it accepts utf-8 string instead of cesu-8 string.
-*Note*: Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+*Note*:
+ - The difference from [jerry_create_string_sz](#jerry_create_string_sz) is that it accepts utf-8 string instead of cesu-8 string.
+ - Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
 is no longer needed.
 
 **Prototype**
 
 ```c
 jerry_value_t
-jerry_create_string_sz (const jerry_char_t *str_p,
-                        jerry_size_t str_size)
+jerry_create_string_sz_from_utf8 (const jerry_char_t *str_p,
+                                  jerry_size_t str_size)
 ```
 
-- `str_p` - pointer to string
+- `str_p` - non-null pointer to string
 - `str_size` - size of the string
 - return value - value of the created string
 
@@ -4683,6 +4845,65 @@ main (void)
 - [jerry_delete_property](#jerry_delete_property)
 
 
+## jerry_has_internal_property
+
+**Summary**
+
+Checks whether the object has the given internal property.
+
+*Note*:
+ - Properties which were not created with [jerry_set_internal_property](#jerry_set_internal_property) are excluded
+   during the operation.
+ - Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+is no longer needed.
+
+**Prototype**
+
+```c
+bool
+jerry_has_internal_property (const jerry_value_t obj_val,
+                             const jerry_value_t prop_name_val);
+```
+
+- `obj_val` - object value
+- `prop_name_val` - property name
+- return value
+  - true, if the property exists
+  - false, otherwise
+
+*New in version 2.2*.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include "jerryscript.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_value_t global_object = jerry_get_global_object ();
+  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "hidden_property");
+
+  bool has_internal_js_prop = jerry_has_internal_property (global_object, prop_name);
+
+  jerry_release_value (prop_name);
+  jerry_release_value (global_object);
+
+  return 0;
+}
+```
+
+**See also**
+
+- [jerry_delete_internal_property](#jerry_delete_internal_property)
+- [jerry_get_internal_property](#jerry_get_internal_property)
+- [jerry_set_internal_property](#jerry_set_internal_property)
+
+
 ## jerry_delete_property
 
 **Summary**
@@ -4772,6 +4993,52 @@ jerry_delete_property_by_index (const jerry_value_t obj_val,
 - [jerry_get_property_by_index](#jerry_get_property_by_index)
 - [jerry_set_property_by_index](#jerry_set_property_by_index)
 
+## jerry_delete_internal_property
+
+**Summary**
+
+Delete an internal property from an object.
+
+*Note*: Properties which were not created with [jerry_set_internal_property](#jerry_set_internal_property) are excluded
+        during the operation.
+
+**Prototype**
+
+```c
+bool
+jerry_delete_internal_property (const jerry_value_t obj_val,
+                                const jerry_value_t prop_name_val);
+```
+
+- `obj_val` - object value
+- `prop_name_val` - property name
+- return value
+  - true, if property was deleted successfully
+  - false, otherwise
+
+*New in version 2.2*.
+
+**Example**
+
+```c
+{
+  jerry_value_t global_object = jerry_get_global_object ();
+  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "hidden_property");
+
+  bool delete_result = jerry_delete_internal_property (global_object, prop_name);
+  /* use "delete_result" */
+
+  jerry_release_value (prop_name);
+  jerry_release_value (global_object);
+}
+```
+
+**See also**
+
+- [jerry_has_internal_property](#jerry_has_internal_property)
+- [jerry_get_internal_property](#jerry_get_internal_property)
+- [jerry_set_internal_property](#jerry_set_internal_property)
+
 
 ## jerry_get_property
 
@@ -4884,6 +5151,68 @@ jerry_get_property_by_index (const jerry_value_t obj_val,
 - [jerry_set_property](#jerry_set_property)
 - [jerry_set_property_by_index](#jerry_set_property_by_index)
 
+## jerry_get_internal_property
+
+**Summary**
+
+Get value of an internal property to the specified object with the given name.
+
+*Note*:
+ - Properties which were not created with [jerry_set_internal_property](#jerry_set_internal_property) are excluded
+   during the operation.
+ - Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+   is no longer needed.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_get_internal_property (const jerry_value_t obj_val,
+                             const jerry_value_t prop_name_val);
+```
+
+- `obj_val` - object value
+- `prop_name_val` - property name
+- return value
+  - value of property, if the internal property exists
+  - undefined value, if the, if the internal does not property exists
+  - thrown error, otherwise
+
+*New in version 2.2*.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include "jerryscript.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_value_t global_object = jerry_get_global_object ();
+  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "hidden_property");
+
+  jerry_value_t prop_value = jerry_get_internal_property (global_object, prop_name);
+
+  /* use "prop_value" then release it. */
+
+  jerry_release_value (prop_value);
+  jerry_release_value (prop_name);
+  jerry_release_value (global_object);
+
+  return 0;
+}
+```
+
+**See also**
+
+- [jerry_has_internal_property](#jerry_has_internal_property)
+- [jerry_delete_internal_property](#jerry_delete_internal_property)
+- [jerry_set_internal_property](#jerry_set_internal_property)
+
 
 ## jerry_set_property
 
@@ -5001,6 +5330,70 @@ jerry_set_property_by_index (const jerry_value_t obj_val,
 - [jerry_get_property_by_index](#jerry_get_property_by_index)
 
 
+## jerry_set_internal_property
+
+**Summary**
+
+Set an internal property to the specified object with the given name.
+
+*Note*:
+ - The property cannot be accessed from the JavaScript context, only from the public API.
+ - It is different from [jerry_set_object_native_pointer](#jerry_set_object_native_pointer) in that any jerry API value
+   can be hidden from the JavaScript context, not only native pointers.
+
+**Prototype**
+
+```c
+bool
+jerry_set_internal_property (const jerry_value_t obj_val,
+                             const jerry_value_t prop_name_val,
+                             const jerry_value_t value_to_set)
+```
+
+- `obj_val` - object value
+- `prop_name_val` - property name
+- `value_to_set` - value to set
+- return value
+  - true, if success
+  - thrown error, otherwise
+
+*New in version 2.2*.
+
+**Example**
+
+[doctest]: # ()
+
+```c
+#include "jerryscript.h"
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_value_t global_object = jerry_get_global_object ();
+  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "hidden_property");
+  jerry_value_t value_to_set = jerry_create_number (5);
+
+  bool set_result = jerry_set_internal_property (global_object, prop_name, value_to_set);
+
+  /* check the result of internal property set call */
+
+  jerry_release_value (value_to_set);
+  jerry_release_value (prop_name);
+  jerry_release_value (global_object);
+
+  return 0;
+}
+```
+
+**See also**
+
+- [jerry_has_internal_property](#jerry_has_internal_property)
+- [jerry_delete_internal_property](#jerry_delete_internal_property)
+- [jerry_get_internal_property](#jerry_get_internal_property)
+
+
 ## jerry_init_property_descriptor_fields
 
 **Summary**
@@ -5761,7 +6154,10 @@ You can get them by calling [jerry_get_object_native_pointer](#jerry_get_object_
    it will be called by the garbage collector when the object is freed.
  - If the object is only referenced via the "global" object (or one of it's "child"),
    the free callback will be invoked during the execution of `jerry_cleanup`.
- - The free callback **must not** invoke API functions.
+ - The free callback can invoke API functions.
+
+*Note*: If possible do not store API values in native pointers, rather check
+        [jerry_set_internal_property](#jerry_set_internal_property).
 
 **Prototype**
 
@@ -7169,6 +7565,239 @@ main (void)
 - [jerry_create_external_function](#jerry_create_external_function)
 
 
+## jerry_get_resource_name
+
+**Summary**
+
+Get the resource name (usually a file name) of the currently executed script or the given function object.
+
+This function is typically called from native callbacks.
+
+*Notes*:
+- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+is no longer needed.
+- This feature depends on build option (`JERRY_LINE_INFO`) and can be checked
+  in runtime with the `JERRY_FEATURE_LINE_INFO` feature enum value,
+  see: [jerry_is_feature_enabled](#jerry_is_feature_enabled).
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_get_resource_name (jerry_value_t value);
+```
+- `value` - api value to obtain the resource name from
+- return string value constructed from
+  - the currently executed function object's resource name, if the given value is undefined
+  - resource name of the function object, if the given value is a function object
+  - "<anonymous>", otherwise
+
+*New in version 2.2*.
+
+**Example**
+
+[doctest]: # (name="02.API-REFERENCE-jsresourcename.c")
+
+```c
+#include <stdio.h>
+#include <string.h>
+#include "jerryscript.h"
+
+static jerry_value_t
+resource_name_handler (const jerry_value_t function_obj,
+                       const jerry_value_t this_val,
+                       const jerry_value_t args_p[],
+                       const jerry_length_t args_count)
+{
+  jerry_value_t undefined_value = jerry_create_undefined ();
+  jerry_value_t resource_name = jerry_get_resource_name (args_count > 0 ? args_p[0] : undefined_value);
+  jerry_release_value (undefined_value);
+
+  return resource_name;
+} /* resource_name_handler */
+
+int
+main (void)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_value_t global = jerry_get_global_object ();
+
+  /* Register the "resourceName" method. */
+  {
+    jerry_value_t func = jerry_create_external_function (resource_name_handler);
+    jerry_value_t name = jerry_create_string ((const jerry_char_t *) "resourceName");
+    jerry_value_t result = jerry_set_property (global, name, func);
+    jerry_release_value (result);
+    jerry_release_value (name);
+    jerry_release_value (func);
+  }
+
+  jerry_release_value (global);
+
+  const jerry_char_t source[] = "function myFunction() { return resourceName() }; myFunction()";
+  const jerry_char_t resource[] = "demo.js";
+
+  jerry_value_t program = jerry_parse (resource,
+                                       sizeof (resource) - 1,
+                                       source,
+                                       sizeof (source) - 1,
+                                       JERRY_PARSE_NO_OPTS);
+
+  if (!jerry_value_is_error (program))
+  {
+    /* `run_result` contains "demo.js" */
+    jerry_value_t run_result = jerry_run (program);
+
+    /* usage of `run_result` */
+
+    jerry_release_value (run_result);
+  }
+
+  jerry_release_value (program);
+  jerry_cleanup ();
+
+  return 0;
+}
+```
+
+**See also**
+
+- [jerry_create_external_function](#jerry_create_external_function)
+
+## jerry_get_new_target
+
+**Summary**
+
+Returns the current "new.target" JavaScript function at the call site.
+
+If used outside of a native C function it will return "undefined" value.
+
+*Notes*:
+- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+is no longer needed.
+- This feature depends on build option (`JERRY_ES2015`) and can be checked
+  in runtime with the `JERRY_FEATURE_SYMBOL` feature enum value (as symbols are enabled in case of ES2015),
+  see: [jerry_is_feature_enabled](#jerry_is_feature_enabled).
+- If the ES2015 mode is not enabled this method will always return the "undefined" value.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_get_new_target (void);
+```
+- return
+  - "undefined" - if at the call site it was not a constructor call.
+  - function object - if the current call site is in a constructor call.
+
+*New in version 2.2*.
+
+**Example 1**
+
+[doctest]: # (name="02.API-REFERENCE-jsnewtarget-01.c")
+
+```c
+#include <stdio.h>
+#include <string.h>
+#include <jerryscript.h>
+
+static jerry_value_t
+demo_handler (const jerry_value_t func_obj_val,
+              const jerry_value_t this_val,
+              const jerry_value_t args_p[],
+              const jerry_length_t args_cnt)
+{
+  jerry_value_t new_target = jerry_get_new_target ();
+
+  /* new_target is the "demo" JS function object */
+  if (jerry_value_get_type (new_target) == JERRY_TYPE_FUNCTION)
+  {
+    printf ("This is a construct call\r\n");
+  }
+
+  jerry_release_value (new_target);
+
+  return jerry_create_undefined ();
+}
+
+int
+main (int argc, char** argv)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  jerry_value_t function_val = jerry_create_external_function (demo_handler);
+
+  jerry_value_t ret_val = jerry_construct_object (function_val, NULL, 0);
+
+  jerry_release_value (ret_val);
+  jerry_release_value (function_val);
+
+  jerry_cleanup ();
+  return 0;
+}
+```
+
+**Example 2**
+
+[doctest]: # (name="02.API-REFERENCE-jsnewtarget-02.c")
+
+```c
+#include <stdio.h>
+#include <string.h>
+#include <jerryscript.h>
+
+static jerry_value_t
+demo_handler (const jerry_value_t func_obj_val,
+              const jerry_value_t this_val,
+              const jerry_value_t args_p[],
+              const jerry_length_t args_cnt)
+{
+  jerry_value_t new_target = jerry_get_new_target ();
+
+  /* new_target is a JS function object */
+  if (jerry_value_get_type (new_target) == JERRY_TYPE_FUNCTION)
+  {
+    printf ("This is a construct call\r\n");
+  }
+
+  jerry_release_value (new_target);
+
+  return jerry_create_undefined ();
+}
+
+int
+main (int argc, char** argv)
+{
+  jerry_init (JERRY_INIT_EMPTY);
+
+  /* register C method */
+  jerry_value_t global_obj_val = jerry_get_global_object ();
+  jerry_value_t function_val = jerry_create_external_function (demo_handler);
+  jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) "demo");
+  jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
+  jerry_release_value (result_val);
+  jerry_release_value (function_name_val);
+  jerry_release_value (function_val);
+  jerry_release_value (global_obj_val);
+
+  /* Invoke C method via JS */
+  const char *src = "new demo ()";
+  jerry_value_t ret_val = jerry_eval ((const jerry_char_t *) src,
+                                      strlen (src),
+                                      JERRY_PARSE_NO_OPTS);
+
+  jerry_release_value (ret_val);
+
+  jerry_cleanup ();
+  return 0;
+}
+```
+
+**See also**
+
+- [jerry_construct_object](#jerry_construct_object)
+
 # ArrayBuffer and TypedArray functions
 
 These APIs all depend on the ES2015-subset profile.
@@ -7397,6 +8026,89 @@ jerry_get_arraybuffer_pointer (const jerry_value_t value);
 
 - [jerry_create_arraybuffer_external](#jerry_create_arraybuffer_external)
 
+## jerry_is_arraybuffer_detachable
+
+**Summary**
+
+Get if the ArrayBuffer is detachable.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_is_arraybuffer_detachable (const jerry_value_t value);
+```
+
+- `value` - ArrayBuffer to be detached
+- return
+  - boolean value if success
+  - Error otherwise
+
+*New in version 2.2*.
+
+**Example**
+
+```c
+{
+  // create the ArrayBuffer
+  jerry_value_t buffer = jerry_create_arraybuffer (16);
+
+  jerry_value_t res = jerry_is_arraybuffer_detachable (buffer);
+  bool is_detachable = jerry_get_boolean_value (res);
+
+  // release buffer as it is not needed after this point
+  jerry_release_value (res);
+  jerry_release_value (buffer);
+}
+```
+
+**See also**
+
+- [jerry_detach_arraybuffer](#jerry_detach_arraybuffer)
+
+## jerry_detach_arraybuffer
+
+**Summary**
+
+Detach the underlying data block from ArrayBuffer and set its bytelength to 0.
+
+This operation requires the ArrayBuffer to be external that created by
+`jerry_create_arraybuffer_external`.
+
+**Prototype**
+
+```c
+jerry_value_t
+jerry_detach_arraybuffer (const jerry_value_t value);
+```
+
+- `value` - ArrayBuffer to be detached
+- return
+  - null value if success
+  - Error otherwise
+
+*New in version 2.2*.
+
+**Example**
+
+```c
+{
+  uint8_t buf[1];
+  jerry_size_t length = 1;
+  // create the ArrayBuffer
+  jerry_value_t buffer = jerry_create_arraybuffer (length, buf, NULL);
+
+  jerry_value_t res = jerry_detach_arraybuffer (buffer);
+
+  // release buffer as it is not needed after this point
+  jerry_release_value (res);
+  jerry_release_value (buffer);
+}
+```
+
+**See also**
+
+- [jerry_is_arraybuffer_detachable](#jerry_is_arraybuffer_detachable)
 
 ## jerry_get_dataview_buffer
 

jerry-core/CMakeLists.txt

@@ -41,6 +41,7 @@ set(JERRY_VM_EXEC_STOP              OFF     CACHE BOOL   "Enable VM execution st
 set(JERRY_GLOBAL_HEAP_SIZE          "(512)" CACHE STRING "Size of memory heap, in kilobytes")
 set(JERRY_GC_LIMIT                  "(0)"   CACHE STRING "Heap usage limit to trigger garbage collection")
 set(JERRY_STACK_LIMIT               "(0)"   CACHE STRING "Maximum stack usage size, in kilobytes")
+set(JERRY_GC_MARK_LIMIT             "(8)"   CACHE STRING "Maximum depth of recursion during GC mark phase")
 
 # Option overrides
 if(USING_MSVC)
@@ -104,6 +105,7 @@ message(STATUS "JERRY_VM_EXEC_STOP             " ${JERRY_VM_EXEC_STOP})
 message(STATUS "JERRY_GLOBAL_HEAP_SIZE         " ${JERRY_GLOBAL_HEAP_SIZE})
 message(STATUS "JERRY_GC_LIMIT                 " ${JERRY_GC_LIMIT})
 message(STATUS "JERRY_STACK_LIMIT              " ${JERRY_STACK_LIMIT})
+message(STATUS "JERRY_GC_MARK_LIMIT            " ${JERRY_GC_MARK_LIMIT})
 
 # Include directories
 set(INCLUDE_CORE_PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
@@ -305,6 +307,9 @@ set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_GLOBAL_HEAP_SIZE=${JERRY_GLOBAL_HEAP_SI
 # Maximum size of stack memory usage
 set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_STACK_LIMIT=${JERRY_STACK_LIMIT})
 
+# Maximum depth of recursion during GC mark phase
+set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_GC_MARK_LIMIT=${JERRY_GC_MARK_LIMIT})
+
 ## This function is to read "config.h" for default values
 function(read_set_defines FILE PREFIX OUTPUTVAR)
   file(READ "${CMAKE_CURRENT_SOURCE_DIR}/${FILE}" INPUT_FILE_CONTENTS)
@@ -395,6 +400,11 @@ target_include_directories(${JERRY_CORE_NAME} PRIVATE ${INCLUDE_CORE_PRIVATE})
 
 set(JERRY_CORE_PKGCONFIG_REQUIRES)
 set(JERRY_CORE_PKGCONFIG_LIBS)
+set(JERRY_CORE_PKGCONFIG_CFLAGS)
+
+if(ENABLE_LTO)
+  set(JERRY_CORE_PKGCONFIG_CFLAGS "${JERRY_CORE_PKGCONFIG_CFLAGS} -flto")
+endif()
 
 if(JERRY_LIBM)
   target_link_libraries(${JERRY_CORE_NAME} jerry-libm)

jerry-core/api/jerry-snapshot.c

@@ -45,9 +45,9 @@ snapshot_get_global_flags (bool has_regex, /**< regex literal is present */
 #if ENABLED (JERRY_BUILTIN_REGEXP)
   flags |= (has_regex ? JERRY_SNAPSHOT_HAS_REGEX_LITERAL : 0);
 #endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
-#if ENABLED (JERRY_ES2015_CLASS)
+#if ENABLED (JERRY_ES2015)
   flags |= (has_class ? JERRY_SNAPSHOT_HAS_CLASS_LITERAL : 0);
-#endif /* ENABLED (JERRY_ES2015_CLASS) */
+#endif /* ENABLED (JERRY_ES2015) */
 
   return flags;
 } /* snapshot_get_global_flags */
@@ -63,9 +63,9 @@ snapshot_check_global_flags (uint32_t global_flags) /**< global flags */
 #if ENABLED (JERRY_BUILTIN_REGEXP)
   global_flags &= (uint32_t) ~JERRY_SNAPSHOT_HAS_REGEX_LITERAL;
 #endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
-#if ENABLED (JERRY_ES2015_CLASS)
+#if ENABLED (JERRY_ES2015)
   global_flags &= (uint32_t) ~JERRY_SNAPSHOT_HAS_CLASS_LITERAL;
-#endif /* ENABLED (JERRY_ES2015_CLASS) */
+#endif /* ENABLED (JERRY_ES2015) */
 
   return global_flags == snapshot_get_global_flags (false, false);
 } /* snapshot_check_global_flags */
@@ -160,12 +160,19 @@ snapshot_add_compiled_code (ecma_compiled_code_t *compiled_code_p, /**< compiled
   uint8_t *copied_code_start_p = snapshot_buffer_p + globals_p->snapshot_buffer_write_offset;
   ecma_compiled_code_t *copied_code_p = (ecma_compiled_code_t *) copied_code_start_p;
 
-#if ENABLED (JERRY_ES2015_CLASS)
+#if ENABLED (JERRY_ES2015)
+  if (compiled_code_p->status_flags & CBC_CODE_FLAG_HAS_TAGGED_LITERALS)
+  {
+    const char * const error_message_p = "Unsupported feature: tagged template literals.";
+    globals_p->snapshot_error = jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_message_p);
+    return 0;
+  }
+
   if (compiled_code_p->status_flags & CBC_CODE_FLAGS_CONSTRUCTOR)
   {
     globals_p->class_found = true;
   }
-#endif /* ENABLED (JERRY_ES2015_CLASS) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #if ENABLED (JERRY_BUILTIN_REGEXP)
   if (!(compiled_code_p->status_flags & CBC_CODE_FLAGS_FUNCTION))
@@ -292,10 +299,11 @@ static_snapshot_error_unsupported_literal (snapshot_globals_t *globals_p, /**< s
 
   ecma_string_t *error_message_p = ecma_new_ecma_string_from_utf8 (error_prefix, sizeof (error_prefix) - 1);
 
-  literal = ecma_op_to_string (literal);
   JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (literal));
 
-  ecma_string_t *literal_string_p = ecma_get_string_from_value (literal);
+  ecma_string_t *literal_string_p = ecma_op_to_string (literal);
+  JERRY_ASSERT (literal_string_p != NULL);
+
   error_message_p = ecma_concat_ecma_strings (error_message_p, literal_string_p);
   ecma_deref_ecma_string (literal_string_p);
 
@@ -416,7 +424,7 @@ static_snapshot_add_compiled_code (ecma_compiled_code_t *compiled_code_p, /**< c
     }
   }
 
-  if (CBC_NON_STRICT_ARGUMENTS_NEEDED (compiled_code_p))
+  if (compiled_code_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
   {
     buffer_p += ((size_t) compiled_code_p->size) << JMEM_ALIGNMENT_LOG;
     literal_start_p = ((ecma_value_t *) buffer_p) - argument_end;
@@ -488,7 +496,7 @@ jerry_snapshot_set_offsets (uint32_t *buffer_p, /**< buffer */
         }
       }
 
-      if (CBC_NON_STRICT_ARGUMENTS_NEEDED (bytecode_p))
+      if (bytecode_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
       {
         uint8_t *byte_p = (uint8_t *) bytecode_p;
         byte_p += ((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;
@@ -581,7 +589,7 @@ snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of th
     uint8_t *byte_p = (uint8_t *) bytecode_p;
     cbc_uint16_arguments_t *args_p = (cbc_uint16_arguments_t *) byte_p;
 
-    if (CBC_NON_STRICT_ARGUMENTS_NEEDED (bytecode_p))
+    if (bytecode_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
     {
       argument_end = args_p->argument_end;
     }
@@ -595,7 +603,7 @@ snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of th
     uint8_t *byte_p = (uint8_t *) bytecode_p;
     cbc_uint8_arguments_t *args_p = (cbc_uint8_arguments_t *) byte_p;
 
-    if (CBC_NON_STRICT_ARGUMENTS_NEEDED (bytecode_p))
+    if (bytecode_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
     {
       argument_end = args_p->argument_end;
     }
@@ -738,9 +746,9 @@ jerry_generate_snapshot_with_args (const jerry_char_t *resource_name_p, /**< scr
   JERRY_UNUSED (resource_name_p);
   JERRY_UNUSED (resource_name_length);
 
-#if ENABLED (JERRY_LINE_INFO)
+#if ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM)
   JERRY_CONTEXT (resource_name) = ECMA_VALUE_UNDEFINED;
-#endif /* ENABLED (JERRY_LINE_INFO) */
+#endif /* ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM) */
 
   snapshot_globals_t globals;
   ecma_value_t parse_status;
@@ -762,7 +770,7 @@ jerry_generate_snapshot_with_args (const jerry_char_t *resource_name_p, /**< scr
 
   if (ECMA_IS_VALUE_ERROR (parse_status))
   {
-    return ecma_create_error_reference (JERRY_CONTEXT (error_value), true);
+    return ecma_create_error_reference_from_context ();
   }
 
   JERRY_ASSERT (bytecode_data_p != NULL);
@@ -982,8 +990,7 @@ jerry_snapshot_result (const uint32_t *snapshot_p, /**< snapshot */
   if (as_function)
   {
     ecma_object_t *lex_env_p = ecma_get_global_environment ();
-    ecma_object_t *func_obj_p = ecma_op_create_function_object (lex_env_p,
-                                                                bytecode_p);
+    ecma_object_t *func_obj_p = ecma_op_create_simple_function_object (lex_env_p, bytecode_p);
 
     if (!(bytecode_p->status_flags & CBC_CODE_FLAGS_STATIC_FUNCTION))
     {
@@ -1091,7 +1098,7 @@ scan_snapshot_functions (const uint8_t *buffer_p, /**< snapshot buffer start */
         }
       }
 
-      if (CBC_NON_STRICT_ARGUMENTS_NEEDED (bytecode_p))
+      if (bytecode_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
       {
         uint8_t *byte_p = (uint8_t *) bytecode_p;
         byte_p += ((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;
@@ -1169,7 +1176,7 @@ update_literal_offsets (uint8_t *buffer_p, /**< [in,out] snapshot buffer start *
         }
       }
 
-      if (CBC_NON_STRICT_ARGUMENTS_NEEDED (bytecode_p))
+      if (bytecode_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
       {
         uint8_t *byte_p = (uint8_t *) bytecode_p;
         byte_p += ((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;
@@ -1543,42 +1550,6 @@ jerry_append_number_to_buffer (uint8_t *buffer_p, /**< buffer */
                                        utf8_str_size);
 } /* jerry_append_number_to_buffer */
 
-/**
- * Check whether the passed ecma-string is a valid identifier.
- *
- * @return true - if the ecma-string is a valid identifier,
- *         false - otherwise
- */
-static bool
-ecma_string_is_valid_identifier (const ecma_string_t *string_p)
-{
-  bool result = false;
-
-  ECMA_STRING_TO_UTF8_STRING (string_p, str_buffer_p, str_buffer_size);
-
-  if (lit_char_is_identifier_start (str_buffer_p))
-  {
-    const uint8_t *str_start_p = str_buffer_p;
-    const uint8_t *str_end_p = str_buffer_p + str_buffer_size;
-
-    result = true;
-
-    while (str_start_p < str_end_p)
-    {
-      if (!lit_char_is_identifier_part (str_start_p))
-      {
-        result = false;
-        break;
-      }
-      lit_utf8_incr (&str_start_p);
-    }
-  }
-
-  ECMA_FINALIZE_UTF8_STRING (str_buffer_p, str_buffer_size);
-
-  return result;
-} /* ecma_string_is_valid_identifier */
-
 #endif /* ENABLED (JERRY_SNAPSHOT_SAVE) */
 
 /**
@@ -1631,14 +1602,7 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p, /**< input snapsho
     {
       ecma_string_t *literal_p = ecma_get_string_from_value (buffer_p[i]);
 
-      /* NOTE:
-       *      We don't save a literal (in C format) which isn't a valid
-       *      identifier or it's a magic string.
-       * TODO:
-       *      Save all of the literals in C format as well.
-       */
-      if (ecma_get_string_magic (literal_p) == LIT_MAGIC_STRING__COUNT
-          && (!is_c_format || ecma_string_is_valid_identifier (literal_p)))
+      if (ecma_get_string_magic (literal_p) == LIT_MAGIC_STRING__COUNT)
       {
         literal_count++;
       }
@@ -1666,14 +1630,7 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p, /**< input snapsho
     {
       ecma_string_t *literal_p = ecma_get_string_from_value (buffer_p[i]);
 
-      /* NOTE:
-       *      We don't save a literal (in C format) which isn't a valid
-       *      identifier or it's a magic string.
-       * TODO:
-       *      Save all of the literals in C format as well.
-       */
-      if (ecma_get_string_magic (literal_p) == LIT_MAGIC_STRING__COUNT
-          && (!is_c_format || ecma_string_is_valid_identifier (literal_p)))
+      if (ecma_get_string_magic (literal_p) == LIT_MAGIC_STRING__COUNT)
       {
         literal_array[literal_idx++] = literal_p;
       }
@@ -1707,7 +1664,29 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p, /**< input snapsho
     for (lit_utf8_size_t i = 0; i < literal_count; i++)
     {
       lit_buf_p = jerry_append_chars_to_buffer (lit_buf_p, buffer_end_p, "  \"", 0);
-      lit_buf_p = jerry_append_ecma_string_to_buffer (lit_buf_p, buffer_end_p, literal_array[i]);
+      ECMA_STRING_TO_UTF8_STRING (literal_array[i], str_buffer_p, str_buffer_size);
+      for (lit_utf8_size_t j = 0; j < str_buffer_size; j++)
+      {
+        uint8_t byte = str_buffer_p[j];
+        if (byte < 32 || byte > 127)
+        {
+          lit_buf_p = jerry_append_chars_to_buffer (lit_buf_p, buffer_end_p, "\\x", 0);
+          ecma_char_t hex_digit = (ecma_char_t) (byte >> 4);
+          *lit_buf_p++ = (lit_utf8_byte_t) ((hex_digit > 9) ? (hex_digit + ('A' - 10)) : (hex_digit + '0'));
+          hex_digit = (lit_utf8_byte_t) (byte & 0xf);
+          *lit_buf_p++ = (lit_utf8_byte_t) ((hex_digit > 9) ? (hex_digit + ('A' - 10)) : (hex_digit + '0'));
+        }
+        else
+        {
+          if (byte == '\\' || byte == '"')
+          {
+            *lit_buf_p++ = '\\';
+          }
+          *lit_buf_p++ = byte;
+        }
+      }
+
+      ECMA_FINALIZE_UTF8_STRING (str_buffer_p, str_buffer_size);
       lit_buf_p = jerry_append_chars_to_buffer (lit_buf_p, buffer_end_p, "\"", 0);
 
       if (i < literal_count - 1)
@@ -1779,7 +1758,6 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p, /**< input snapsho
 #endif /* ENABLED (JERRY_SNAPSHOT_SAVE) */
 } /* jerry_get_literals_from_snapshot */
 
-
 /**
  * Generate snapshot function from specified source and arguments
  *

jerry-core/api/jerry.c

@@ -71,6 +71,25 @@ JERRY_STATIC_ASSERT ((int) RE_FLAG_GLOBAL == (int) JERRY_REGEXP_FLAG_GLOBAL
                      re_flags_t_must_be_equal_to_jerry_regexp_flags_t);
 #endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
 
+#if ENABLED (JERRY_ES2015_BUILTIN_PROMISE)
+/* The internal ECMA_PROMISE_STATE_* values are "one byte away" from the API values */
+JERRY_STATIC_ASSERT (((ECMA_PROMISE_STATE_PENDING + 1) == JERRY_PROMISE_STATE_PENDING)
+                     && ((ECMA_PROMISE_STATE_FULFILLED + 1) == JERRY_PROMISE_STATE_FULFILLED)
+                     && ((ECMA_PROMISE_STATE_REJECTED + 1) == JERRY_PROMISE_STATE_REJECTED),
+                     promise_internal_state_matches_external);
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
+
+/**
+ * Offset between internal and external arithmetic operator types
+ */
+#define ECMA_NUMBER_ARITHMETIC_OP_API_OFFSET (JERRY_BIN_OP_SUB - NUMBER_ARITHMETIC_SUBTRACTION)
+
+JERRY_STATIC_ASSERT (((NUMBER_ARITHMETIC_SUBTRACTION + ECMA_NUMBER_ARITHMETIC_OP_API_OFFSET) == JERRY_BIN_OP_SUB)
+                     && ((NUMBER_ARITHMETIC_MULTIPLICATION + ECMA_NUMBER_ARITHMETIC_OP_API_OFFSET) == JERRY_BIN_OP_MUL)
+                     && ((NUMBER_ARITHMETIC_DIVISION + ECMA_NUMBER_ARITHMETIC_OP_API_OFFSET) == JERRY_BIN_OP_DIV)
+                     && ((NUMBER_ARITHMETIC_REMAINDER + ECMA_NUMBER_ARITHMETIC_OP_API_OFFSET) == JERRY_BIN_OP_REM),
+                     number_arithmetics_operation_type_matches_external);
+
 #if !ENABLED (JERRY_PARSER) && !ENABLED (JERRY_SNAPSHOT_EXEC)
 #error "JERRY_SNAPSHOT_EXEC must be enabled if JERRY_PARSER is disabled!"
 #endif /* !ENABLED (JERRY_PARSER) && !ENABLED (JERRY_SNAPSHOT_EXEC) */
@@ -172,7 +191,7 @@ jerry_init (jerry_init_flag_t flags) /**< combination of Jerry flags */
   JERRY_ASSERT (!(JERRY_CONTEXT (status_flags) & ECMA_STATUS_API_AVAILABLE));
 
   /* Zero out all non-external members. */
-  memset (&JERRY_CONTEXT (JERRY_CONTEXT_FIRST_MEMBER), 0,
+  memset ((char *) &JERRY_CONTEXT_STRUCT + offsetof (jerry_context_t, JERRY_CONTEXT_FIRST_MEMBER), 0,
           sizeof (jerry_context_t) - offsetof (jerry_context_t, JERRY_CONTEXT_FIRST_MEMBER));
 
   JERRY_CONTEXT (jerry_init_flags) = flags;
@@ -438,8 +457,7 @@ jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a
   ecma_free_value (parse_status);
 
   ecma_object_t *lex_env_p = ecma_get_global_environment ();
-  ecma_object_t *func_obj_p = ecma_op_create_function_object (lex_env_p,
-                                                              bytecode_data_p);
+  ecma_object_t *func_obj_p = ecma_op_create_simple_function_object (lex_env_p, bytecode_data_p);
   ecma_bytecode_deref (bytecode_data_p);
 
   return ecma_make_object_value (func_obj_p);
@@ -520,8 +538,7 @@ jerry_parse_function (const jerry_char_t *resource_name_p, /**< resource name (u
   ecma_free_value (parse_status);
 
   ecma_object_t *lex_env_p = ecma_get_global_environment ();
-  ecma_object_t *func_obj_p = ecma_op_create_function_object (lex_env_p,
-                                                              bytecode_data_p);
+  ecma_object_t *func_obj_p = ecma_op_create_simple_function_object (lex_env_p, bytecode_data_p);
   ecma_bytecode_deref (bytecode_data_p);
 
   return ecma_make_object_value (func_obj_p);
@@ -811,12 +828,12 @@ jerry_value_is_symbol (const jerry_value_t value) /**< api value */
 {
   jerry_assert_api_available ();
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   return ecma_is_value_symbol (value);
-#else /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#else /* !ENABLED (JERRY_ES2015) */
   JERRY_UNUSED (value);
   return false;
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 } /* jerry_value_is_symbol */
 
 /**
@@ -870,12 +887,12 @@ jerry_value_get_type (const jerry_value_t value) /**< input value to check */
     {
       return JERRY_TYPE_STRING;
     }
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
     case LIT_MAGIC_STRING_SYMBOL:
     {
       return JERRY_TYPE_SYMBOL;
     }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
     case LIT_MAGIC_STRING_FUNCTION:
     {
       return JERRY_TYPE_FUNCTION;
@@ -940,9 +957,9 @@ jerry_is_feature_enabled (const jerry_feature_t feature) /**< feature to check *
 #if ENABLED (JERRY_ES2015_BUILTIN_PROMISE)
           || feature == JERRY_FEATURE_PROMISE
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
           || feature == JERRY_FEATURE_SYMBOL
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 #if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
           || feature == JERRY_FEATURE_TYPEDARRAY
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
@@ -1019,6 +1036,17 @@ jerry_binary_operation (jerry_binary_operation_t op, /**< operation */
       ecma_object_t *proto_obj_p = ecma_get_object_from_value (rhs);
       return jerry_return (ecma_op_object_has_instance (proto_obj_p, lhs));
     }
+    case JERRY_BIN_OP_ADD:
+    {
+      return jerry_return (opfunc_addition (lhs, rhs));
+    }
+    case JERRY_BIN_OP_SUB:
+    case JERRY_BIN_OP_MUL:
+    case JERRY_BIN_OP_DIV:
+    case JERRY_BIN_OP_REM:
+    {
+      return jerry_return (do_number_arithmetic (op - ECMA_NUMBER_ARITHMETIC_OP_API_OFFSET, lhs, rhs));
+    }
     default:
     {
       return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Unsupported binary operation")));
@@ -1288,7 +1316,13 @@ jerry_value_to_string (const jerry_value_t value) /**< input value */
     return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_value_msg_p)));
   }
 
-  return jerry_return (ecma_op_to_string (value));
+  ecma_string_t *str_p = ecma_op_to_string (value);
+  if (JERRY_UNLIKELY (str_p == NULL))
+  {
+    return ecma_create_error_reference_from_context ();
+  }
+
+  return jerry_return (ecma_make_string_value (str_p));
 } /* jerry_value_to_string */
 
 /**
@@ -1638,11 +1672,11 @@ jerry_create_symbol (const jerry_value_t value) /**< api value */
     return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
   }
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   return jerry_return (ecma_op_create_symbol (&value, 1));
-#else /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#else /* !ENABLED (JERRY_ES2015) */
   return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Symbol is not supported.")));
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 } /* jerry_create_symbol */
 
 /**
@@ -1704,18 +1738,19 @@ jerry_get_array_length (const jerry_value_t value) /**< api value */
 {
   jerry_assert_api_available ();
 
-  if (!jerry_value_is_array (value))
+  if (!jerry_value_is_object (value))
   {
     return 0;
   }
 
-  ecma_value_t len_value = ecma_op_object_get_by_magic_id (ecma_get_object_from_value (value),
-                                                           LIT_MAGIC_STRING_LENGTH);
+  ecma_object_t *object_p = ecma_get_object_from_value (value);
 
-  jerry_length_t length = ecma_number_to_uint32 (ecma_get_number_from_value (len_value));
-  ecma_free_value (len_value);
+  if (JERRY_LIKELY (ecma_get_object_type (object_p) == ECMA_OBJECT_TYPE_ARRAY))
+  {
+    return ecma_array_get_length (object_p);
+  }
 
-  return length;
+  return 0;
 } /* jerry_get_array_length */
 
 /**
@@ -1996,6 +2031,46 @@ jerry_has_own_property (const jerry_value_t obj_val, /**< object value */
   return ecma_make_boolean_value (has_property);
 } /* jerry_has_own_property */
 
+/**
+ * Checks whether the object has the given internal property.
+ *
+ * @return true  - if the internal property exists
+ *         false - otherwise
+ */
+bool
+jerry_has_internal_property (const jerry_value_t obj_val, /**< object value */
+                             const jerry_value_t prop_name_val) /**< property name value */
+{
+  jerry_assert_api_available ();
+
+  if (!ecma_is_value_object (obj_val)
+      || !ecma_is_value_prop_name (prop_name_val))
+  {
+    return false;
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (obj_val);
+
+  ecma_string_t *internal_string_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_API_INTERNAL);
+
+  if (ecma_op_object_is_fast_array (obj_p))
+  {
+    return false;
+  }
+
+  ecma_property_t *property_p = ecma_find_named_property (obj_p, internal_string_p);
+
+  if (property_p == NULL)
+  {
+    return false;
+  }
+
+  ecma_object_t *internal_object_p = ecma_get_object_from_value (ECMA_PROPERTY_VALUE_PTR (property_p)->value);
+  property_p = ecma_find_named_property (internal_object_p, ecma_get_prop_name_from_value (prop_name_val));
+
+  return property_p != NULL;
+} /* jerry_has_internal_property */
+
 /**
  * Delete a property from an object.
  *
@@ -2046,6 +2121,53 @@ jerry_delete_property_by_index (const jerry_value_t obj_val, /**< object value *
   return ecma_is_value_true (ret_value);
 } /* jerry_delete_property_by_index */
 
+/**
+ * Delete an internal property from an object.
+ *
+ * @return true  - if property was deleted successfully
+ *         false - otherwise
+ */
+bool
+jerry_delete_internal_property (const jerry_value_t obj_val, /**< object value */
+                                const jerry_value_t prop_name_val) /**< property name value */
+{
+  jerry_assert_api_available ();
+
+  if (!ecma_is_value_object (obj_val)
+      || !ecma_is_value_prop_name (prop_name_val))
+  {
+    return false;
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (obj_val);
+
+  ecma_string_t *internal_string_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_API_INTERNAL);
+
+  if (ecma_op_object_is_fast_array (obj_p))
+  {
+    return true;
+  }
+
+  ecma_property_t *property_p = ecma_find_named_property (obj_p, internal_string_p);
+
+  if (property_p == NULL)
+  {
+    return true;
+  }
+
+  ecma_object_t *internal_object_p = ecma_get_object_from_value (ECMA_PROPERTY_VALUE_PTR (property_p)->value);
+  property_p = ecma_find_named_property (internal_object_p, ecma_get_prop_name_from_value (prop_name_val));
+
+  if (property_p == NULL)
+  {
+    return true;
+  }
+
+  ecma_delete_property (internal_object_p, ECMA_PROPERTY_VALUE_PTR (property_p));
+
+  return true;
+} /* jerry_delete_internal_property */
+
 /**
  * Get value of a property to the specified object with the given name.
  *
@@ -2092,13 +2214,60 @@ jerry_get_property_by_index (const jerry_value_t obj_val, /**< object value */
     return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
   }
 
-  ecma_string_t *str_idx_p = ecma_new_ecma_string_from_uint32 (index);
-  ecma_value_t ret_value = ecma_op_object_get (ecma_get_object_from_value (obj_val), str_idx_p);
-  ecma_deref_ecma_string (str_idx_p);
+  ecma_value_t ret_value = ecma_op_object_get_by_uint32_index (ecma_get_object_from_value (obj_val), index);
 
   return jerry_return (ret_value);
 } /* jerry_get_property_by_index */
 
+/**
+ * Get value of an internal property to the specified object with the given name.
+ *
+ * Note:
+ *      returned value must be freed with jerry_release_value, when it is no longer needed.
+ *
+ * @return value of the internal property - if the internal property exists
+ *         undefined value - if the internal does not property exists
+ *         value marked with error flag - otherwise
+ */
+jerry_value_t
+jerry_get_internal_property (const jerry_value_t obj_val, /**< object value */
+                             const jerry_value_t prop_name_val) /**< property name value */
+{
+  jerry_assert_api_available ();
+
+  if (!ecma_is_value_object (obj_val)
+      || !ecma_is_value_prop_name (prop_name_val))
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (obj_val);
+
+  ecma_string_t *internal_string_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_API_INTERNAL);
+
+  if (ecma_op_object_is_fast_array (obj_p))
+  {
+    return jerry_return (ECMA_VALUE_UNDEFINED);
+  }
+
+  ecma_property_t *property_p = ecma_find_named_property (obj_p, internal_string_p);
+
+  if (property_p == NULL)
+  {
+    return jerry_return (ECMA_VALUE_UNDEFINED);
+  }
+
+  ecma_object_t *internal_object_p = ecma_get_object_from_value (ECMA_PROPERTY_VALUE_PTR (property_p)->value);
+  property_p = ecma_find_named_property (internal_object_p, ecma_get_prop_name_from_value (prop_name_val));
+
+  if (property_p == NULL)
+  {
+    return jerry_return (ECMA_VALUE_UNDEFINED);
+  }
+
+  return jerry_return (ecma_copy_value (ECMA_PROPERTY_VALUE_PTR (property_p)->value));
+} /* jerry_get_internal_property */
+
 /**
  * Set a property to the specified object with the given name.
  *
@@ -2150,16 +2319,95 @@ jerry_set_property_by_index (const jerry_value_t obj_val, /**< object value */
     return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
   }
 
-  ecma_string_t *str_idx_p = ecma_new_ecma_string_from_uint32 ((uint32_t) index);
-  ecma_value_t ret_value = ecma_op_object_put (ecma_get_object_from_value (obj_val),
-                                               str_idx_p,
-                                               value_to_set,
-                                               true);
-  ecma_deref_ecma_string (str_idx_p);
+  ecma_value_t ret_value = ecma_op_object_put_by_uint32_index (ecma_get_object_from_value (obj_val),
+                                                               index,
+                                                               value_to_set,
+                                                               true);
 
   return jerry_return (ret_value);
 } /* jerry_set_property_by_index */
 
+/**
+ * Set an internal property to the specified object with the given name.
+ *
+ * Note:
+ *      - the property cannot be accessed from the JavaScript context, only from the public API
+ *      - returned value must be freed with jerry_release_value, when it is no longer needed.
+ *
+ * @return true value - if the operation was successful
+ *         value marked with error flag - otherwise
+ */
+bool
+jerry_set_internal_property (const jerry_value_t obj_val, /**< object value */
+                             const jerry_value_t prop_name_val, /**< property name value */
+                             const jerry_value_t value_to_set) /**< value to set */
+{
+  jerry_assert_api_available ();
+
+  if (ecma_is_value_error_reference (value_to_set)
+      || !ecma_is_value_object (obj_val)
+      || !ecma_is_value_prop_name (prop_name_val))
+  {
+    return false;
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (obj_val);
+
+  ecma_string_t *internal_string_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_API_INTERNAL);
+
+  if (ecma_op_object_is_fast_array (obj_p))
+  {
+    ecma_fast_array_convert_to_normal (obj_p);
+  }
+
+  ecma_property_t *property_p = ecma_find_named_property (obj_p, internal_string_p);
+  ecma_object_t *internal_object_p;
+
+  if (property_p == NULL)
+  {
+    ecma_property_value_t *value_p = ecma_create_named_data_property (obj_p,
+                                                                      internal_string_p,
+                                                                      ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE,
+                                                                      NULL);
+
+    internal_object_p = ecma_create_object (NULL,
+                                            sizeof (ecma_extended_object_t),
+                                            ECMA_OBJECT_TYPE_CLASS);
+    {
+      ecma_extended_object_t *container_p = (ecma_extended_object_t *) internal_object_p;
+      container_p->u.class_prop.class_id = LIT_INTERNAL_MAGIC_STRING_INTERNAL_OBJECT;
+      container_p->u.class_prop.extra_info = 0;
+      container_p->u.class_prop.u.length = 0;
+    }
+
+    value_p->value = ecma_make_object_value (internal_object_p);
+    ecma_deref_object (internal_object_p);
+  }
+  else
+  {
+    internal_object_p = ecma_get_object_from_value (ECMA_PROPERTY_VALUE_PTR (property_p)->value);
+  }
+
+  ecma_string_t *prop_name_p = ecma_get_prop_name_from_value (prop_name_val);
+  property_p = ecma_find_named_property (internal_object_p, prop_name_p);
+
+  if (property_p == NULL)
+  {
+    ecma_property_value_t *value_p = ecma_create_named_data_property (internal_object_p,
+                                                                      prop_name_p,
+                                                                      ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE,
+                                                                      NULL);
+
+    value_p->value = ecma_copy_value_if_not_object (value_to_set);
+  }
+  else
+  {
+    ecma_named_data_property_assign_value (internal_object_p, ECMA_PROPERTY_VALUE_PTR (property_p), value_to_set);
+  }
+
+  return true;
+} /* jerry_set_internal_property */
+
 /**
  * Initialize property descriptor.
  */
@@ -2461,8 +2709,16 @@ jerry_call_function (const jerry_value_t func_obj_val, /**< function object to c
 {
   jerry_assert_api_available ();
 
-  if (jerry_value_is_function (func_obj_val))
+  if (jerry_value_is_function (func_obj_val) && !ecma_is_value_error_reference (this_val))
   {
+    for (jerry_size_t i = 0; i < args_count; i++)
+    {
+      if (ecma_is_value_error_reference (args_p[i]))
+      {
+        return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_value_msg_p)));
+      }
+    }
+
     return jerry_invoke_function (false, func_obj_val, this_val, args_p, args_count);
   }
 
@@ -2488,6 +2744,14 @@ jerry_construct_object (const jerry_value_t func_obj_val, /**< function object t
 
   if (jerry_value_is_constructor (func_obj_val))
   {
+    for (jerry_size_t i = 0; i < args_count; i++)
+    {
+      if (ecma_is_value_error_reference (args_p[i]))
+      {
+        return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_value_msg_p)));
+      }
+    }
+
     ecma_value_t this_val = ECMA_VALUE_UNDEFINED;
     return jerry_invoke_function (true, func_obj_val, this_val, args_p, args_count);
   }
@@ -2521,6 +2785,9 @@ jerry_get_object_keys (const jerry_value_t obj_val) /**< object value */
 /**
  * Get the prototype of the specified object
  *
+ * Note:
+ *      returned value must be freed with jerry_release_value, when it is no longer needed.
+ *
  * @return prototype object or null value - if success
  *         value marked with error flag - otherwise
  */
@@ -2542,6 +2809,7 @@ jerry_get_prototype (const jerry_value_t obj_val) /**< object value */
   }
 
   ecma_object_t *proto_obj_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t, obj_p->u2.prototype_cp);
+  ecma_ref_object (proto_obj_p);
 
   return ecma_make_object_value (proto_obj_p);
 } /* jerry_get_prototype */
@@ -2578,6 +2846,40 @@ jerry_set_prototype (const jerry_value_t obj_val, /**< object value */
   return ECMA_VALUE_TRUE;
 } /* jerry_set_prototype */
 
+/**
+ * Utility to check if a given object can be used for the foreach api calls.
+ *
+ * Some objects/classes uses extra internal objects to correctly store data.
+ * These extre object should never be exposed externally to the API user.
+ *
+ * @returns true - if the user can access the object in the callback.
+ *          false - if the object is an internal object which should no be accessed by the user.
+ */
+static
+bool jerry_object_is_valid_foreach (ecma_object_t *object_p) /**< object to test */
+{
+  if (ecma_is_lexical_environment (object_p))
+  {
+    return false;
+  }
+
+  ecma_object_type_t object_type = ecma_get_object_type (object_p);
+
+  if (object_type == ECMA_OBJECT_TYPE_CLASS)
+  {
+    ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) object_p;
+    switch (ext_object_p->u.class_prop.class_id)
+    {
+      /* An object's internal property object should not be iterable by foreach. */
+      case LIT_INTERNAL_MAGIC_STRING_INTERNAL_OBJECT:
+      /* Containers are internal data, do not iterate on them. */
+      case LIT_INTERNAL_MAGIC_STRING_CONTAINER: return false;
+    }
+  }
+
+  return true;
+} /* jerry_object_is_valid_foreach */
+
 /**
  * Traverse objects.
  *
@@ -2598,7 +2900,7 @@ jerry_objects_foreach (jerry_objects_foreach_t foreach_p, /**< function pointer
   {
     ecma_object_t *iter_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t, iter_cp);
 
-    if (!ecma_is_lexical_environment (iter_p)
+    if (jerry_object_is_valid_foreach (iter_p)
         && !foreach_p (ecma_make_object_value (iter_p), user_data_p))
     {
       return true;
@@ -2630,14 +2932,13 @@ jerry_objects_foreach_by_native_info (const jerry_object_native_info_t *native_i
 
   ecma_native_pointer_t *native_pointer_p;
 
-
   jmem_cpointer_t iter_cp = JERRY_CONTEXT (ecma_gc_objects_cp);
 
   while (iter_cp != JMEM_CP_NULL)
   {
     ecma_object_t *iter_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t, iter_cp);
 
-    if (!ecma_is_lexical_environment (iter_p))
+    if (jerry_object_is_valid_foreach (iter_p))
     {
       native_pointer_p = ecma_get_native_pointer_value (iter_p, (void *) native_info_p);
       if (native_pointer_p
@@ -2701,7 +3002,7 @@ jerry_get_object_native_pointer (const jerry_value_t obj_val, /**< object to get
  * Note:
  *      If a non-NULL free callback is specified in the native type info,
  *      it will be called by the garbage collector when the object is freed.
- *      This callback **must not** invoke API functions.
+ *      Referred values by this method must have at least 1 reference. (Correct API usage satisfies this condition)
  *      The type info always overwrites the previous value, so passing
  *      a NULL value deletes the current type info.
  */
@@ -2800,7 +3101,7 @@ jerry_foreach_object_property (const jerry_value_t obj_val, /**< object value */
     return true;
   }
 
-  ecma_free_value (JERRY_CONTEXT (error_value));
+  jcontext_release_exception ();
   return false;
 } /* jerry_foreach_object_property */
 
@@ -2823,6 +3124,11 @@ jerry_resolve_or_reject_promise (jerry_value_t promise, /**< the promise value *
     return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
   }
 
+  if (ecma_is_value_error_reference (argument))
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_value_msg_p)));
+  }
+
   lit_magic_string_id_t prop_name = (is_resolve ? LIT_INTERNAL_MAGIC_STRING_RESOLVE_FUNCTION
                                                 : LIT_INTERNAL_MAGIC_STRING_REJECT_FUNCTION);
 
@@ -2845,6 +3151,60 @@ jerry_resolve_or_reject_promise (jerry_value_t promise, /**< the promise value *
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
 } /* jerry_resolve_or_reject_promise */
 
+/**
+ * Get the result of a promise.
+ *
+ * @return - Promise result
+ *         - Type error if the promise support was not enabled or the input was not a promise object
+ */
+jerry_value_t
+jerry_get_promise_result (const jerry_value_t promise) /**< promise object to get the result from */
+{
+  jerry_assert_api_available ();
+
+#if ENABLED (JERRY_ES2015_BUILTIN_PROMISE)
+  if (!jerry_value_is_promise (promise))
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
+  }
+
+  return ecma_promise_get_result (ecma_get_object_from_value (promise));
+#else /* !ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
+  JERRY_UNUSED (promise);
+  return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Promise not supported.")));
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
+} /* jerry_get_promise_result */
+
+/**
+ * Get the state of a promise object.
+ *
+ * @return - the state of the promise (one of the jerry_promise_state_t enum values)
+ *         - JERRY_PROMISE_STATE_NONE is only returned if the input is not a promise object
+ *           or the promise support was not enabled.
+ */
+jerry_promise_state_t
+jerry_get_promise_state (const jerry_value_t promise) /**< promise object to get the state from */
+{
+  jerry_assert_api_available ();
+
+#if ENABLED (JERRY_ES2015_BUILTIN_PROMISE)
+  if (!jerry_value_is_promise (promise))
+  {
+    return JERRY_PROMISE_STATE_NONE;
+  }
+
+  uint8_t state = ecma_promise_get_state (ecma_get_object_from_value (promise));
+
+  JERRY_ASSERT (state < ECMA_PROMISE_STATE__COUNT);
+
+  /* Static assert above guarantees the mapping from internal type to external type. */
+  return (jerry_promise_state_t) (state + 1);
+#else /* !ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
+  JERRY_UNUSED (promise);
+  return JERRY_PROMISE_STATE_NONE;
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
+} /* jerry_get_promise_state */
+
 /**
  * Call the SymbolDescriptiveString ecma builtin operation on the symbol value.
  *
@@ -2859,7 +3219,7 @@ jerry_get_symbol_descriptive_string (const jerry_value_t symbol) /**< symbol val
 {
   jerry_assert_api_available ();
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   if (!ecma_is_value_symbol (symbol))
   {
     return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
@@ -2867,11 +3227,11 @@ jerry_get_symbol_descriptive_string (const jerry_value_t symbol) /**< symbol val
 
   /* Note: This operation cannot throw an error */
   return ecma_get_symbol_descriptive_string (symbol);
-#else /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#else /* !ENABLED (JERRY_ES2015) */
   JERRY_UNUSED (symbol);
 
   return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Symbol is not supported.")));
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 } /** jerry_get_symbol_descriptive_string */
 
 /**
@@ -3038,6 +3398,77 @@ jerry_get_backtrace (uint32_t max_depth) /**< depth limit of the backtrace */
   return vm_get_backtrace (max_depth);
 } /* jerry_get_backtrace */
 
+/**
+ * Get the resource name (usually a file name) of the currently executed script or the given function object
+ *
+ * Note: returned value must be freed with jerry_release_value, when it is no longer needed
+ *
+ * @return JS string constructed from
+ *         - the currently executed function object's resource name, if the given value is undefined
+ *         - resource name of the function object, if the given value is a function object
+ *         - "<anonymous>", otherwise
+ */
+jerry_value_t
+jerry_get_resource_name (const jerry_value_t value) /**< jerry api value */
+{
+#if ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM)
+  if (ecma_is_value_undefined (value))
+  {
+    if (JERRY_CONTEXT (vm_top_context_p) != NULL)
+    {
+      return ecma_copy_value (JERRY_CONTEXT (vm_top_context_p)->resource_name);
+    }
+  }
+#endif /* ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM) */
+#if ENABLED (JERRY_LINE_INFO)
+  else if (ecma_is_value_object (value))
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (value);
+
+    if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_FUNCTION
+        && !ecma_get_object_is_builtin (obj_p))
+    {
+      ecma_extended_object_t *ext_func_p = (ecma_extended_object_t *) obj_p;
+
+      const ecma_compiled_code_t *bytecode_data_p = ecma_op_function_get_compiled_code (ext_func_p);
+
+      return ecma_copy_value (ecma_op_resource_name (bytecode_data_p));
+    }
+  }
+#endif /* ENABLED (JERRY_LINE_INFO) */
+
+  JERRY_UNUSED (value);
+  return ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
+} /* jerry_get_resource_name */
+
+/**
+ * Access the "new.target" value.
+ *
+ * The "new.target" value depends on the current call site. That is
+ * this method will only have a function object result if, at the call site
+ * it was called inside a constructor method invoked with "new".
+ *
+ * @return "undefined" - if at the call site it was not a constructor call.
+ *         function object - if the current call site is in a constructor call.
+ */
+jerry_value_t
+jerry_get_new_target (void)
+{
+#if ENABLED (JERRY_ES2015)
+  ecma_object_t *current_new_target = JERRY_CONTEXT (current_new_target);
+
+  if (current_new_target == NULL || current_new_target == JERRY_CONTEXT_INVALID_NEW_TARGET)
+  {
+    return jerry_create_undefined ();
+  }
+
+  ecma_ref_object (current_new_target);
+  return ecma_make_object_value (current_new_target);
+#else /* !ENABLED (JERRY_ES2015) */
+  return jerry_create_undefined ();
+#endif /* ENABLED (JERRY_ES2015) */
+} /* jerry_get_new_target */
+
 /**
  * Check if the given value is an ArrayBuffer object.
  *
@@ -3087,7 +3518,7 @@ jerry_create_arraybuffer (const jerry_length_t size) /**< size of the ArrayBuffe
  *     * the size is specified in bytes.
  *     * the buffer passed should be at least the specified bytes big.
  *     * if the typed arrays are disabled this will return a TypeError.
- *     * if the size is zero or the buffer_p is a null pointer this will return a RangeError.
+ *     * if the size is zero or buffer_p is a null pointer this will return an empty ArrayBuffer.
  *
  * @return value of the construced ArrayBuffer object
  */
@@ -3099,14 +3530,19 @@ jerry_create_arraybuffer_external (const jerry_length_t size, /**< size of the b
   jerry_assert_api_available ();
 
 #if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
-  if (size == 0 || buffer_p == NULL)
+  ecma_object_t *arraybuffer;
+
+  if (JERRY_UNLIKELY (size == 0 || buffer_p == NULL))
   {
-    return jerry_throw (ecma_raise_range_error (ECMA_ERR_MSG ("invalid buffer size or storage reference")));
+    arraybuffer = ecma_arraybuffer_new_object_external (0, NULL, (ecma_object_native_free_callback_t) free_cb);
+  }
+  else
+  {
+    arraybuffer = ecma_arraybuffer_new_object_external (size,
+                                                        buffer_p,
+                                                        (ecma_object_native_free_callback_t) free_cb);
   }
 
-  ecma_object_t *arraybuffer = ecma_arraybuffer_new_object_external (size,
-                                                                     buffer_p,
-                                                                     (ecma_object_native_free_callback_t) free_cb);
   return jerry_return (ecma_make_object_value (arraybuffer));
 #else /* !ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
   JERRY_UNUSED (size);
@@ -3271,6 +3707,59 @@ jerry_get_arraybuffer_pointer (const jerry_value_t array_buffer) /**< Array Buff
   return NULL;
 } /* jerry_get_arraybuffer_pointer */
 
+/**
+ * Get if the ArrayBuffer is detachable.
+ *
+ * @return boolean value - if success
+ *         value marked with error flag - otherwise
+ */
+jerry_value_t
+jerry_is_arraybuffer_detachable (const jerry_value_t value) /**< ArrayBuffer */
+{
+  jerry_assert_api_available ();
+
+#if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
+  if (ecma_is_arraybuffer (value))
+  {
+    ecma_object_t *buffer_p = ecma_get_object_from_value (value);
+    return ecma_arraybuffer_is_detachable (buffer_p) ? ECMA_VALUE_TRUE : ECMA_VALUE_FALSE;
+  }
+#else /* !ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
+  JERRY_UNUSED (value);
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
+  return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Expects an ArrayBuffer")));
+} /* jerry_is_arraybuffer_detachable */
+
+/**
+ * Detach the underlying data block from ArrayBuffer and set its bytelength to 0.
+ * This operation requires the ArrayBuffer to be external that created by
+ * `jerry_create_arraybuffer_external`.
+ *
+ * @return null value - if success
+ *         value marked with error flag - otherwise
+ */
+jerry_value_t
+jerry_detach_arraybuffer (const jerry_value_t value) /**< ArrayBuffer */
+{
+  jerry_assert_api_available ();
+
+#if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
+  if (ecma_is_arraybuffer (value))
+  {
+    ecma_object_t *buffer_p = ecma_get_object_from_value (value);
+    bool detached = ecma_arraybuffer_detach (buffer_p);
+    if (!detached)
+    {
+      return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Expects a detachable ArrayBuffer.")));
+    }
+    return ECMA_VALUE_NULL;
+  }
+#else /* !ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
+  JERRY_UNUSED (value);
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
+  return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Expects an ArrayBuffer")));
+} /* jerry_detach_arraybuffer */
+
 /**
  * DataView related functions
  */
@@ -3326,15 +3815,7 @@ jerry_value_is_dataview (const jerry_value_t value) /**< value to check if it is
   jerry_assert_api_available ();
 
 #if ENABLED (JERRY_ES2015_BUILTIN_DATAVIEW)
-  if (!ecma_is_value_object (value))
-  {
-    return false;
-  }
-
-  ecma_dataview_object_t *dataview_object_p = (ecma_dataview_object_t *) ecma_get_object_from_value (value);
-
-  return (ecma_get_object_type (&dataview_object_p->header.object) == ECMA_OBJECT_TYPE_CLASS
-          && dataview_object_p->header.u.class_prop.class_id == LIT_MAGIC_STRING_DATAVIEW_UL);
+  return ecma_is_dataview (value);
 #else /* !ENABLED (JERRY_ES2015_BUILTIN_DATAVIEW) */
   JERRY_UNUSED (value);
   return false;
@@ -3516,6 +3997,7 @@ jerry_create_typedarray (jerry_typedarray_type_t type_name, /**< type of TypedAr
   ecma_object_t *prototype_obj_p = ecma_builtin_get (prototype_id);
 
   ecma_value_t array_value = ecma_typedarray_create_object_with_length (length,
+                                                                        NULL,
                                                                         prototype_obj_p,
                                                                         element_size_shift,
                                                                         id);
@@ -3548,6 +4030,11 @@ jerry_create_typedarray_for_arraybuffer_sz (jerry_typedarray_type_t type_name, /
   jerry_assert_api_available ();
 
 #if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
+  if (ecma_is_value_error_reference (arraybuffer))
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_value_msg_p)));
+  }
+
   ecma_builtin_id_t prototype_id = 0;
   ecma_typedarray_type_t id = 0;
   uint8_t element_size_shift = 0;
@@ -3600,6 +4087,11 @@ jerry_create_typedarray_for_arraybuffer (jerry_typedarray_type_t type_name, /**<
   jerry_assert_api_available ();
 
 #if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
+  if (ecma_is_value_error_reference (arraybuffer))
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_value_msg_p)));
+  }
+
   jerry_length_t byteLength = jerry_get_arraybuffer_byte_length (arraybuffer);
   return jerry_create_typedarray_for_arraybuffer_sz (type_name, arraybuffer, 0, byteLength);
 #else /* !ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
@@ -3759,6 +4251,11 @@ jerry_json_stringify (const jerry_value_t object_to_stringify) /**< a jerry_obje
 #if ENABLED (JERRY_BUILTIN_JSON)
   ecma_value_t ret_value = ecma_builtin_json_string_from_object (object_to_stringify);
 
+  if (ecma_is_value_error_reference (object_to_stringify))
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_value_msg_p)));
+  }
+
   if (ecma_is_value_undefined (ret_value))
   {
     ret_value = jerry_throw (ecma_raise_syntax_error (ECMA_ERR_MSG ("JSON stringify error.")));

jerry-core/config.h

@@ -79,18 +79,10 @@
 # define JERRY_ES2015 1
 #endif /* !defined (JERRY_ES2015) */
 
-#ifndef JERRY_ES2015_BUILTIN
-# define JERRY_ES2015_BUILTIN JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_BUILTIN) */
-
 #ifndef JERRY_ES2015_BUILTIN_DATAVIEW
 # define JERRY_ES2015_BUILTIN_DATAVIEW JERRY_ES2015
 #endif /* !defined (JERRY_ES2015_BUILTIN_DATAVIEW) */
 
-#ifndef JERRY_ES2015_BUILTIN_ITERATOR
-# define JERRY_ES2015_BUILTIN_ITERATOR JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_BUILTIN_ITERATOR) */
-
 #ifndef JERRY_ES2015_BUILTIN_MAP
 # define JERRY_ES2015_BUILTIN_MAP JERRY_ES2015
 #endif /* !defined (JERRY_ES2015_BUILTIN_MAP) */
@@ -99,50 +91,30 @@
 # define JERRY_ES2015_BUILTIN_SET JERRY_ES2015
 #endif /* !defined (JERRY_ES2015_BUILTIN_SET) */
 
+#ifndef JERRY_ES2015_BUILTIN_WEAKMAP
+# define JERRY_ES2015_BUILTIN_WEAKMAP JERRY_ES2015
+#endif /* !defined (JERRY_ES2015_BUILTIN_WEAKMAP) */
+
+#ifndef JERRY_ES2015_BUILTIN_WEAKSET
+# define JERRY_ES2015_BUILTIN_WEAKSET JERRY_ES2015
+#endif /* !defined (JERRY_ES2015_BUILTIN_WEAKSET) */
+
 #ifndef JERRY_ES2015_BUILTIN_PROMISE
 # define JERRY_ES2015_BUILTIN_PROMISE JERRY_ES2015
 #endif /* !defined (JERRY_ES2015_BUILTIN_PROMISE) */
 
-#ifndef JERRY_ES2015_BUILTIN_SYMBOL
-# define JERRY_ES2015_BUILTIN_SYMBOL JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_BUILTIN_SYMBOL) */
+#ifndef JERRY_ES2015_BUILTIN_REFLECT
+# define JERRY_ES2015_BUILTIN_REFLECT JERRY_ES2015
+#endif /* !defined (JERRY_ES2015_BUILTIN_REFLECT) */
 
 #ifndef JERRY_ES2015_BUILTIN_TYPEDARRAY
 # define JERRY_ES2015_BUILTIN_TYPEDARRAY JERRY_ES2015
 #endif /* !defined (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
 
-#ifndef JERRY_ES2015_ARROW_FUNCTION
-# define JERRY_ES2015_ARROW_FUNCTION JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_ARROW_FUNCTION) */
-
-#ifndef JERRY_ES2015_CLASS
-# define JERRY_ES2015_CLASS JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_CLASS) */
-
-#ifndef JERRY_ES2015_FOR_OF
-# define JERRY_ES2015_FOR_OF JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_FOR_OF) */
-
-#ifndef JERRY_ES2015_FUNCTION_PARAMETER_INITIALIZER
-# define JERRY_ES2015_FUNCTION_PARAMETER_INITIALIZER JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_FUNCTION_PARAMETER_INITIALIZER) */
-
-#ifndef JERRY_ES2015_FUNCTION_REST_PARAMETER
-# define JERRY_ES2015_FUNCTION_REST_PARAMETER JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_FUNCTION_REST_PARAMETER) */
-
-#ifndef JERRY_ES2015_OBJECT_INITIALIZER
-# define JERRY_ES2015_OBJECT_INITIALIZER JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_OBJECT_INITIALIZER) */
-
 #ifndef JERRY_ES2015_MODULE_SYSTEM
 # define JERRY_ES2015_MODULE_SYSTEM JERRY_ES2015
 #endif /* !defined (JERRY_ES2015_MODULE_SYSTEM) */
 
-#ifndef JERRY_ES2015_TEMPLATE_STRINGS
-# define JERRY_ES2015_TEMPLATE_STRINGS JERRY_ES2015
-#endif /* !defined (JERRY_ES2015_TEMPLATE_STRINGS) */
-
 /**
  * Engine internal and misc configurations.
  */
@@ -229,6 +201,15 @@
 # define JERRY_STACK_LIMIT (0)
 #endif /* !defined (JERRY_STACK_LIMIT) */
 
+/**
+ * Maximum depth of recursion during GC mark phase
+ *
+ * Default value: 8
+ */
+#ifndef JERRY_GC_MARK_LIMIT
+# define JERRY_GC_MARK_LIMIT (8)
+#endif /* !defined (JERRY_GC_MARK_LIMIT) */
+
 /**
  * Enable/Disable property lookup cache.
  *
@@ -474,7 +455,6 @@
 # define JERRY_ATTR_GLOBAL_HEAP
 #endif /* !defined (JERRY_ATTR_GLOBAL_HEAP) */
 
-
 /**
  * Sanity check for macros to see if the values are 0 or 1
  *
@@ -535,18 +515,6 @@
 || ((JERRY_ES2015 != 0) && (JERRY_ES2015 != 1))
 # error "Invalid value for JERRY_ES2015 macro."
 #endif
-#if !defined (JERRY_ES2015_ARROW_FUNCTION) \
-|| ((JERRY_ES2015_ARROW_FUNCTION != 0) && (JERRY_ES2015_ARROW_FUNCTION != 1))
-# error "Invalid value for JERRY_ES2015_ARROW_FUNCTION macro."
-#endif
-#if !defined (JERRY_ES2015_BUILTIN) \
-|| ((JERRY_ES2015_BUILTIN != 0) && (JERRY_ES2015_BUILTIN != 1))
-# error "Invalid value for JERRY_ES2015_BUILTIN macro."
-#endif
-#if !defined (JERRY_ES2015_BUILTIN_ITERATOR) \
-|| ((JERRY_ES2015_BUILTIN_ITERATOR != 0) && (JERRY_ES2015_BUILTIN_ITERATOR != 1))
-# error "Invalid value for JERRY_ES2015_BUILTIN_ITERATOR macro."
-#endif
 #if !defined (JERRY_ES2015_BUILTIN_DATAVIEW) \
 || ((JERRY_ES2015_BUILTIN_DATAVIEW != 0) && (JERRY_ES2015_BUILTIN_DATAVIEW != 1))
 # error "Invalid value for JERRY_ES2015_BUILTIN_DATAVIEW macro."
@@ -555,50 +523,34 @@
 || ((JERRY_ES2015_BUILTIN_MAP != 0) && (JERRY_ES2015_BUILTIN_MAP != 1))
 # error "Invalid value for JERRY_ES2015_BUILTIN_MAP macro."
 #endif
+#if !defined (JERRY_ES2015_BUILTIN_REFLECT) \
+|| ((JERRY_ES2015_BUILTIN_REFLECT != 0) && (JERRY_ES2015_BUILTIN_REFLECT != 1))
+# error "Invalid value for JERRY_ES2015_BUILTIN_REFLECT macro."
+#endif
 #if !defined (JERRY_ES2015_BUILTIN_SET) \
 || ((JERRY_ES2015_BUILTIN_SET != 0) && (JERRY_ES2015_BUILTIN_SET != 1))
 # error "Invalid value for JERRY_ES2015_BUILTIN_SET macro."
 #endif
+#if !defined (JERRY_ES2015_BUILTIN_WEAKMAP) \
+|| ((JERRY_ES2015_BUILTIN_WEAKMAP != 0) && (JERRY_ES2015_BUILTIN_WEAKMAP != 1))
+# error "Invalid value for JERRY_ES2015_BUILTIN_WEAKMAP macro."
+#endif
+#if !defined (JERRY_ES2015_BUILTIN_WEAKSET) \
+|| ((JERRY_ES2015_BUILTIN_WEAKSET != 0) && (JERRY_ES2015_BUILTIN_WEAKSET != 1))
+# error "Invalid value for JERRY_ES2015_BUILTIN_WEAKSET macro."
+#endif
 #if !defined (JERRY_ES2015_BUILTIN_PROMISE) \
 || ((JERRY_ES2015_BUILTIN_PROMISE != 0) && (JERRY_ES2015_BUILTIN_PROMISE != 1))
 # error "Invalid value for JERRY_ES2015_BUILTIN_PROMISE macro."
 #endif
-#if !defined (JERRY_ES2015_BUILTIN_SYMBOL) \
-|| ((JERRY_ES2015_BUILTIN_SYMBOL != 0) && (JERRY_ES2015_BUILTIN_SYMBOL != 1))
-# error "Invalid value for JERRY_ES2015_BUILTIN_SYMBOL macro."
-#endif
 #if !defined (JERRY_ES2015_BUILTIN_TYPEDARRAY) \
 || ((JERRY_ES2015_BUILTIN_TYPEDARRAY != 0) && (JERRY_ES2015_BUILTIN_TYPEDARRAY != 1))
 # error "Invalid value for JERRY_ES2015_BUILTIN_TYPEDARRAY macro."
 #endif
-#if !defined (JERRY_ES2015_CLASS) \
-|| ((JERRY_ES2015_CLASS != 0) && (JERRY_ES2015_CLASS != 1))
-# error "Invalid value for JERRY_ES2015_CLASS macro."
-#endif
-#if !defined (JERRY_ES2015_FOR_OF) \
-|| ((JERRY_ES2015_FOR_OF != 0) && (JERRY_ES2015_FOR_OF != 1))
-# error "Invalid value for JERRY_ES2015_FOR_OF macro."
-#endif
-#if !defined (JERRY_ES2015_FUNCTION_PARAMETER_INITIALIZER) \
-|| ((JERRY_ES2015_FUNCTION_PARAMETER_INITIALIZER != 0) && (JERRY_ES2015_FUNCTION_PARAMETER_INITIALIZER != 1))
-# error "Invalid value for JERRY_ES2015_FUNCTION_PARAMETER_INITIALIZER macro."
-#endif
-#if !defined (JERRY_ES2015_FUNCTION_REST_PARAMETER) \
-|| ((JERRY_ES2015_FUNCTION_REST_PARAMETER != 0) && (JERRY_ES2015_FUNCTION_REST_PARAMETER != 1))
-# error "Invalid value for JERRY_ES2015_FUNCTION_REST_PARAMETER macro."
-#endif
-#if !defined (JERRY_ES2015_OBJECT_INITIALIZER) \
-|| ((JERRY_ES2015_OBJECT_INITIALIZER != 0) && (JERRY_ES2015_OBJECT_INITIALIZER != 1))
-# error "Invalid value for JERRY_ES2015_OBJECT_INITIALIZER macro."
-#endif
 #if !defined (JERRY_ES2015_MODULE_SYSTEM) \
 || ((JERRY_ES2015_MODULE_SYSTEM != 0) && (JERRY_ES2015_MODULE_SYSTEM != 1))
 # error "Invalid value for JERRY_ES2015_MODULE_SYSTEM macro."
 #endif
-#if !defined (JERRY_ES2015_TEMPLATE_STRINGS) \
-|| ((JERRY_ES2015_TEMPLATE_STRINGS != 0) && (JERRY_ES2015_TEMPLATE_STRINGS != 1))
-# error "Invalid value for JERRY_ES2015_TEMPLATE_STRINGS macro."
-#endif
 
 /**
  * Internal options.
@@ -628,6 +580,9 @@
 #if !defined (JERRY_STACK_LIMIT) || (JERRY_STACK_LIMIT < 0)
 # error "Invalid value for 'JERRY_STACK_LIMIT' macro."
 #endif
+#if !defined (JERRY_GC_MARK_LIMIT) || (JERRY_GC_MARK_LIMIT < 0)
+# error "Invalid value for 'JERRY_GC_MARK_LIMIT' macro."
+#endif
 #if !defined (JERRY_LCACHE) \
 || ((JERRY_LCACHE != 0) && (JERRY_LCACHE != 1))
 # error "Invalid value for 'JERRY_LCACHE' macro."
@@ -697,7 +652,6 @@
 # error "Invalid value for 'JERRY_VM_EXEC_STOP' macro."
 #endif
 
-
 #define ENABLED(FEATURE) ((FEATURE) == 1)
 #define DISABLED(FEATURE) ((FEATURE) != 1)
 
@@ -712,4 +666,14 @@
 #  error "Date does not support float32"
 #endif
 
+/**
+ * Wrap container types into a single guard
+ */
+#if ENABLED (JERRY_ES2015_BUILTIN_MAP) || ENABLED (JERRY_ES2015_BUILTIN_SET) \
+|| ENABLED (JERRY_ES2015_BUILTIN_WEAKMAP) || ENABLED (JERRY_ES2015_BUILTIN_WEAKSET)
+# define JERRY_ES2015_BUILTIN_CONTAINER 1
+#else
+# define JERRY_ES2015_BUILTIN_CONTAINER 0
+#endif
+
 #endif /* !JERRYSCRIPT_CONFIG_H */

jerry-core/debugger/debugger.c

@@ -235,7 +235,7 @@ jerry_debugger_send_scope_chain (void)
 
     if (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE)
     {
-      if ((lex_env_p->type_flags_refs & ECMA_OBJECT_FLAG_NON_CLOSURE) != 0)
+      if ((lex_env_p->type_flags_refs & ECMA_OBJECT_FLAG_BLOCK) != 0)
       {
         message_type_p->string[buffer_pos++] = JERRY_DEBUGGER_SCOPE_NON_CLOSURE;
       }
@@ -304,7 +304,7 @@ jerry_debugger_get_variable_type (ecma_value_t value) /**< input ecma value */
   {
     JERRY_ASSERT (ecma_is_value_object (value));
 
-    if (ecma_object_get_class_name (ecma_get_object_from_value (value)) == LIT_MAGIC_STRING_ARRAY_UL)
+    if (ecma_get_object_type (ecma_get_object_from_value (value)) == ECMA_OBJECT_TYPE_ARRAY)
     {
       ret_value = JERRY_DEBUGGER_VALUE_ARRAY;
     }
@@ -458,14 +458,9 @@ jerry_debugger_send_scope_variables (const uint8_t *recv_buffer_p) /**< pointer
     JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND);
     ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
 
-    if (JERRY_UNLIKELY (ecma_get_object_type (binding_obj_p) == ECMA_OBJECT_TYPE_ARRAY))
+    if (JERRY_UNLIKELY (ecma_op_object_is_fast_array (binding_obj_p)))
     {
-      ecma_extended_object_t *ext_binding_obj_p = (ecma_extended_object_t *) binding_obj_p;
-
-      if (ext_binding_obj_p->u.array.is_fast_mode)
-      {
-        ecma_fast_array_convert_to_normal (binding_obj_p);
-      }
+      ecma_fast_array_convert_to_normal (binding_obj_p);
     }
 
     prop_iter_cp = binding_obj_p->u1.property_list_cp;
@@ -508,22 +503,22 @@ jerry_debugger_send_scope_variables (const uint8_t *recv_buffer_p) /**< pointer
         ecma_deref_ecma_string (prop_name);
 
         ecma_property_value_t prop_value_p = prop_pair_p->values[i];
-        ecma_value_t property_value;
 
         uint8_t variable_type = jerry_debugger_get_variable_type (prop_value_p.value);
 
-        property_value = ecma_op_to_string (prop_value_p.value);
+        ecma_string_t *str_p = ecma_op_to_string (prop_value_p.value);
+        JERRY_ASSERT (str_p != NULL);
 
         if (!jerry_debugger_copy_variables_to_string_message (variable_type,
-                                                              ecma_get_string_from_value (property_value),
+                                                              str_p,
                                                               message_string_p,
                                                               &buffer_pos))
         {
-          ecma_free_value (property_value);
+          ecma_deref_ecma_string (str_p);
           return;
         }
 
-        ecma_free_value (property_value);
+        ecma_deref_ecma_string (str_p);
       }
     }
 
@@ -560,28 +555,23 @@ jerry_debugger_send_eval (const lit_utf8_byte_t *eval_string_p, /**< evaluated s
   {
     if (eval_string_p[4] != JERRY_DEBUGGER_EVAL_EVAL)
     {
+      JERRY_ASSERT (eval_string_p[4] == JERRY_DEBUGGER_EVAL_THROW || eval_string_p[4] == JERRY_DEBUGGER_EVAL_ABORT);
       JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_VM_EXCEPTION_THROWN);
-      JERRY_CONTEXT (error_value) = result;
 
       /* Stop where the error is caught. */
       JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_VM_STOP);
       JERRY_CONTEXT (debugger_stop_context) = NULL;
 
-      if (eval_string_p[4] == JERRY_DEBUGGER_EVAL_THROW)
-      {
-        JERRY_CONTEXT (status_flags) |= ECMA_STATUS_EXCEPTION;
-      }
-      else
-      {
-        JERRY_CONTEXT (status_flags) &= (uint32_t) ~ECMA_STATUS_EXCEPTION;
-      }
+      jcontext_raise_exception (result);
+      jcontext_set_abort_flag (eval_string_p[4] == JERRY_DEBUGGER_EVAL_ABORT);
 
       return true;
     }
 
     if (!ecma_is_value_string (result))
     {
-      ecma_value_t to_string_value = ecma_op_to_string (result);
+      ecma_string_t *str_p = ecma_op_to_string (result);
+      ecma_value_t to_string_value = ecma_make_string_value (str_p);
       ecma_free_value (result);
       result = to_string_value;
     }
@@ -618,8 +608,10 @@ jerry_debugger_send_eval (const lit_utf8_byte_t *eval_string_p, /**< evaluated s
     else
     {
       /* Primitive type. */
-      message = ecma_op_to_string (result);
-      JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (message));
+      ecma_string_t *str_p = ecma_op_to_string (result);
+      JERRY_ASSERT (str_p != NULL);
+
+      message = ecma_make_string_value (str_p);
     }
 
     ecma_free_value (result);
@@ -1158,7 +1150,6 @@ jerry_debugger_receive (jerry_debugger_uint8_data_t **message_data_p) /**< [out]
   }
 } /* jerry_debugger_receive */
 
-
 #undef JERRY_DEBUGGER_CHECK_PACKET_SIZE
 
 /**
@@ -1222,7 +1213,6 @@ jerry_debugger_send_type (jerry_debugger_header_type_t type) /**< message type *
   jerry_debugger_send (sizeof (jerry_debugger_send_type_t));
 } /* jerry_debugger_send_type */
 
-
 /**
  * Send the type signal to the client.
  *
@@ -1521,12 +1511,11 @@ jerry_debugger_exception_object_to_string (ecma_value_t exception_obj_value) /**
  *         false - otherwise
  */
 bool
-jerry_debugger_send_exception_string (void)
+jerry_debugger_send_exception_string (ecma_value_t exception_value)
 {
+  JERRY_ASSERT (jcontext_has_pending_exception ());
   ecma_string_t *string_p = NULL;
 
-  ecma_value_t exception_value = JERRY_CONTEXT (error_value);
-
   if (ecma_is_value_object (exception_value))
   {
     string_p = jerry_debugger_exception_object_to_string (exception_value);
@@ -1543,8 +1532,7 @@ jerry_debugger_send_exception_string (void)
   }
   else
   {
-    exception_value = ecma_op_to_string (exception_value);
-    string_p = ecma_get_string_from_value (exception_value);
+    string_p = ecma_op_to_string (exception_value);
   }
 
   ECMA_STRING_TO_UTF8_STRING (string_p, string_data_p, string_size);

jerry-core/debugger/debugger.h

@@ -484,7 +484,7 @@ bool jerry_debugger_send_string (uint8_t message_type, uint8_t sub_type, const u
 bool jerry_debugger_send_function_cp (jerry_debugger_header_type_t type, ecma_compiled_code_t *compiled_code_p);
 bool jerry_debugger_send_parse_function (uint32_t line, uint32_t column);
 void jerry_debugger_send_memstats (void);
-bool jerry_debugger_send_exception_string (void);
+bool jerry_debugger_send_exception_string (ecma_value_t exception_value);
 
 #endif /* ENABLED (JERRY_DEBUGGER) */
 

jerry-core/ecma/base/ecma-globals.h

@@ -62,6 +62,7 @@ typedef enum
   ECMA_STATUS_HIGH_PRESSURE_GC  = (1u << 2), /**< last gc was under high pressure */
 #endif /* ENABLED (JERRY_PROPRETY_HASHMAP) */
   ECMA_STATUS_EXCEPTION         = (1u << 3), /**< last exception is a normal exception */
+  ECMA_STATUS_ABORT             = (1u << 4), /**< last exception is an abort */
 } ecma_status_flag_t;
 
 /**
@@ -105,6 +106,9 @@ typedef enum
   ECMA_PARSE_HAS_IMPL_SUPER = (1u << 4), /**< the current context has implicit parent class */
   ECMA_PARSE_HAS_STATIC_SUPER = (1u << 5), /**< the current context is a static class method */
   ECMA_PARSE_EVAL = (1u << 6), /**< eval is called */
+  ECMA_PARSE_MODULE = (1u << 7), /**< module is parsed */
+  ECMA_PARSE_FUNCTION = (1u << 8), /**< a function body is parsed or the code is inside a function */
+  ECMA_PARSE_GENERATOR_FUNCTION = (1u << 9), /**< generator function is parsed */
 } ecma_parse_opts_t;
 
 /**
@@ -188,6 +192,9 @@ enum
   ECMA_VALUE_REGISTER_REF = ECMA_MAKE_VALUE (8), /**< register reference,
                                                   *   a special "base" value for vm */
   ECMA_VALUE_IMPLICIT_CONSTRUCTOR = ECMA_MAKE_VALUE (9), /**< special value for bound class constructors */
+  ECMA_VALUE_UNINITIALIZED = ECMA_MAKE_VALUE (10), /**< a special value for uninitialized let/const declarations */
+  ECMA_VALUE_SPREAD_ELEMENT = ECMA_MAKE_VALUE (11), /**< a special value for spread elements in array initialization
+                                                     *   or function call argument list */
 };
 
 #if !ENABLED (JERRY_NUMBER_TYPE_FLOAT64)
@@ -327,10 +334,11 @@ typedef enum
                                        *   that are not indices */
   ECMA_LIST_ENUMERABLE = (1 << 1), /**< exclude non-enumerable properties */
   ECMA_LIST_PROTOTYPE = (1 << 2), /**< list properties from prototype chain */
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
-  ECMA_LIST_SYMBOLS = (1 << 3), /**< list symbol properties only */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
-  ECMA_LIST_CONVERT_FAST_ARRAYS = (1 << 4), /**< after listing the properties convert
+#if ENABLED (JERRY_ES2015)
+  ECMA_LIST_SYMBOLS = (1 << 3), /**< list symbol properties */
+  ECMA_LIST_SYMBOLS_ONLY = (1 << 4), /**< list symbol properties only */
+#endif /* ENABLED (JERRY_ES2015) */
+  ECMA_LIST_CONVERT_FAST_ARRAYS = (1 << 5), /**< after listing the properties convert
                                              *   the fast access mode array back to normal array */
 } ecma_list_properties_options_t;
 
@@ -602,15 +610,15 @@ typedef enum
 {
   ECMA_OBJECT_TYPE_GENERAL = 0, /**< all objects that are not belongs to the sub-types below. */
   ECMA_OBJECT_TYPE_CLASS = 1, /**< Objects with class property */
-  ECMA_OBJECT_TYPE_FUNCTION = 2, /**< Function objects (15.3), created through 13.2 routine */
-  ECMA_OBJECT_TYPE_EXTERNAL_FUNCTION = 3, /**< External (host) function object */
-  ECMA_OBJECT_TYPE_ARRAY = 4, /**< Array object (15.4) */
-  ECMA_OBJECT_TYPE_BOUND_FUNCTION = 5, /**< Function objects (15.3), created through 15.3.4.5 routine */
-  ECMA_OBJECT_TYPE_PSEUDO_ARRAY  = 6, /**< Array-like object, such as Arguments object (10.6) */
-#if ENABLED (JERRY_ES2015_ARROW_FUNCTION)
-  ECMA_OBJECT_TYPE_ARROW_FUNCTION = 7, /**< arrow function objects */
-#endif /* ENABLED (JERRY_ES2015_ARROW_FUNCTION) */
-
+  ECMA_OBJECT_TYPE_ARRAY = 2, /**< Array object (15.4) */
+  ECMA_OBJECT_TYPE_PSEUDO_ARRAY  = 3, /**< Array-like object, such as Arguments object (10.6) */
+  /* Note: these 4 types must be in this order. See IsCallable operation.  */
+  ECMA_OBJECT_TYPE_FUNCTION = 4, /**< Function objects (15.3), created through 13.2 routine */
+#if ENABLED (JERRY_ES2015)
+  ECMA_OBJECT_TYPE_ARROW_FUNCTION = 5, /**< arrow function objects */
+#endif /* ENABLED (JERRY_ES2015) */
+  ECMA_OBJECT_TYPE_BOUND_FUNCTION = 6, /**< Function objects (15.3), created through 15.3.4.5 routine */
+  ECMA_OBJECT_TYPE_EXTERNAL_FUNCTION = 7, /**< External (host) function object */
   /* Types between 13-15 cannot have a built-in flag. See ecma_lexical_environment_type_t. */
 
   ECMA_OBJECT_TYPE__MAX /**< maximum value */
@@ -649,7 +657,8 @@ typedef enum
   ECMA_LEXICAL_ENVIRONMENT_TYPE__MAX = ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND /**< maximum value */
 } ecma_lexical_environment_type_t;
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * Types of array iterators.
  */
@@ -658,8 +667,9 @@ typedef enum
   ECMA_ITERATOR_KEYS, /**< List only key indices */
   ECMA_ITERATOR_VALUES, /**< List only key values */
   ECMA_ITERATOR_KEYS_VALUES, /**< List key indices and values */
-} ecma_iterator_type_t;
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+} ecma_array_iterator_type_t;
+
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Offset for JERRY_CONTEXT (status_flags) top 8 bits.
@@ -709,19 +719,32 @@ typedef enum
 /**
  * Non closure flag for debugger.
  */
-#if ENABLED (JERRY_DEBUGGER)
-#define ECMA_OBJECT_FLAG_NON_CLOSURE 0x20
-#endif /* ENABLED (JERRY_DEBUGGER) */
+#define ECMA_OBJECT_FLAG_BLOCK ECMA_OBJECT_FLAG_EXTENSIBLE
+
+/**
+ * Bitshift index for an ecma-object reference count field
+ */
+#define ECMA_OBJECT_REF_SHIFT 6
+
+/**
+ * Bitmask for an ecma-object reference count field
+ */
+#define ECMA_OBJECT_REF_MASK (((1u << 10) - 1) << ECMA_OBJECT_REF_SHIFT)
 
 /**
  * Value for increasing or decreasing the object reference counter.
  */
-#define ECMA_OBJECT_REF_ONE (1u << 6)
+#define ECMA_OBJECT_REF_ONE (1u << ECMA_OBJECT_REF_SHIFT)
 
 /**
- * Maximum value of the object reference counter (1023).
+ * Represents non-visited white object
  */
-#define ECMA_OBJECT_MAX_REF (0x3ffu << 6)
+#define ECMA_OBJECT_NON_VISITED (0x3ffu << ECMA_OBJECT_REF_SHIFT)
+
+/**
+ * Maximum value of the object reference counter (1022).
+ */
+#define ECMA_OBJECT_MAX_REF (ECMA_OBJECT_NON_VISITED - ECMA_OBJECT_REF_ONE)
 
 /**
  * Description of ECMA-object or lexical environment
@@ -732,8 +755,8 @@ typedef struct
   /** type : 4 bit : ecma_object_type_t or ecma_lexical_environment_type_t
                      depending on ECMA_OBJECT_FLAG_BUILT_IN_OR_LEXICAL_ENV
       flags : 2 bit : ECMA_OBJECT_FLAG_BUILT_IN_OR_LEXICAL_ENV,
-                      ECMA_OBJECT_FLAG_EXTENSIBLE or ECMA_OBJECT_FLAG_NON_CLOSURE
-      refs : 10 bit (max 1023) */
+                      ECMA_OBJECT_FLAG_EXTENSIBLE or ECMA_OBJECT_FLAG_BLOCK
+      refs : 10 bit (max 1022) */
   uint16_t type_flags_refs;
 
   /** next in the object chain maintained by the garbage collector */
@@ -822,10 +845,13 @@ typedef struct
     struct
     {
       uint32_t length; /**< length property value */
-      ecma_property_t length_prop; /**< length property */
-      bool is_fast_mode; /**< true - if the array is a fast access mode array
-                          *   false - otherwise */
-      uint8_t hole_count; /**< Number of array holes in a fast access mode array */
+      union
+      {
+        ecma_property_t length_prop; /**< length property */
+        uint32_t hole_count; /**< number of array holes in a fast access mode array
+                              *   multiplied ECMA_FAST_ACCESS_HOLE_ONE */
+      } u;
+
     } array;
 
     /**
@@ -848,6 +874,7 @@ typedef struct
         ecma_value_t lex_env_cp; /**< for arguments: lexical environment */
         ecma_value_t arraybuffer; /**< for typedarray: internal arraybuffer */
         ecma_value_t iterated_value; /**< for %Iterator%: [[IteratedObject]] property */
+        ecma_value_t spread_value; /**< for spread object: spreaded element */
       } u2;
     } pseudo_array;
 
@@ -885,7 +912,6 @@ typedef struct
 #define ECMA_FAST_ARRAY_ALIGN_LENGTH(length) \
   (uint32_t) ((((length)) + ECMA_FAST_ARRAY_ALIGNMENT - 1) / ECMA_FAST_ARRAY_ALIGNMENT * ECMA_FAST_ARRAY_ALIGNMENT)
 
-
 /**
  * Compiled byte code data.
  */
@@ -913,7 +939,7 @@ typedef struct
 
 #endif /* ENABLED (JERRY_SNAPSHOT_EXEC) */
 
-#if ENABLED (JERRY_ES2015_ARROW_FUNCTION)
+#if ENABLED (JERRY_ES2015)
 
 /**
  * Description of arrow function objects.
@@ -939,18 +965,18 @@ typedef struct
 
 #endif /* ENABLED (JERRY_SNAPSHOT_EXEC) */
 
-#endif /* ENABLED (JERRY_ES2015_ARROW_FUNCTION) */
+#endif /* ENABLED (JERRY_ES2015) */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_MAP) || ENABLED (JERRY_ES2015_BUILTIN_SET)
+#if ENABLED (JERRY_ES2015_BUILTIN_CONTAINER)
 /**
- * Description of Map/Set objects.
+ * Flags for container objects
  */
-typedef struct
+typedef enum
 {
-  ecma_extended_object_t header; /**< header part */
-  uint32_t size; /**< size of the map object */
-} ecma_map_object_t;
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_MAP) || ENABLED (JERRY_ES2015_BUILTIN_SET) */
+  ECMA_CONTAINER_FLAGS_EMPTY = (0), /** empty flags */
+  ECMA_CONTAINER_FLAGS_WEAK = (1 << 0) /** container object is weak */
+} ecma_container_flags_t;
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_CONTAINER) */
 
 typedef enum
 {
@@ -1148,6 +1174,26 @@ typedef union
  * See also: ECMA_262 v5, 15.7.3.2
  */
 # define ECMA_NUMBER_MAX_VALUE (FLT_MAX)
+/**
+ * Number.EPSILON
+ *
+ * See also: ECMA_262 v6, 20.1.2.1
+ */
+# define  ECMA_NUMBER_EPSILON ((ecma_number_t) 1.1920928955078125e-7)
+
+/**
+ * Number.MAX_SAFE_INTEGER
+ *
+ * See also: ECMA_262 v6, 20.1.2.6
+ */
+# define ECMA_NUMBER_MAX_SAFE_INTEGER ((ecma_number_t) 0xFFFFFF)
+
+/**
+ * Number.MIN_SAFE_INTEGER
+ *
+ * See also: ECMA_262 v6, 20.1.2.8
+ */
+# define ECMA_NUMBER_MIN_SAFE_INTEGER ((ecma_number_t) -0xFFFFFF)
 #elif ENABLED (JERRY_NUMBER_TYPE_FLOAT64)
 /**
  * Number.MAX_VALUE (i.e., the maximum value of ecma-number)
@@ -1155,29 +1201,36 @@ typedef union
  * See also: ECMA_262 v5, 15.7.3.2
  */
 # define ECMA_NUMBER_MAX_VALUE ((ecma_number_t) 1.7976931348623157e+308)
+
 /**
  * Number.MIN_VALUE (i.e., the smallest positive value of ecma-number)
  *
  * See also: ECMA_262 v5, 15.7.3.3
  */
 # define ECMA_NUMBER_MIN_VALUE ((ecma_number_t) 5e-324)
-#endif /* !ENABLED (JERRY_NUMBER_TYPE_FLOAT64) */
-#if ENABLED (JERRY_ES2015_BUILTIN)
+
 /**
  * Number.EPSILON
  *
  * See also: ECMA_262 v6, 20.1.2.1
  */
 # define  ECMA_NUMBER_EPSILON ((ecma_number_t) 2.2204460492503130808472633361816e-16)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
-#if ENABLED (JERRY_ES2015_BUILTIN)
+
 /**
  * Number.MAX_SAFE_INTEGER
  *
- * See also: ECMA_262 v6, 20.1.2.1
+ * See also: ECMA_262 v6, 20.1.2.6
  */
 # define ECMA_NUMBER_MAX_SAFE_INTEGER ((ecma_number_t) 0x1FFFFFFFFFFFFF)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+
+/**
+ * Number.MIN_SAFE_INTEGER
+ *
+ * See also: ECMA_262 v6, 20.1.2.8
+ */
+# define ECMA_NUMBER_MIN_SAFE_INTEGER ((ecma_number_t) -0x1FFFFFFFFFFFFF)
+#endif /* !ENABLED (JERRY_NUMBER_TYPE_FLOAT64) */
+
 /**
  * Euler number
  */
@@ -1703,6 +1756,27 @@ typedef struct
 
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
 
+#if ENABLED (JERRY_ES2015)
+
+/**
+ * Executable (e.g. generator, async) object flags.
+ */
+typedef enum
+{
+  ECMA_EXECUTABLE_OBJECT_COMPLETED = (1u << 0), /**< executable object is completed and cannot be resumed */
+  ECMA_EXECUTABLE_OBJECT_RUNNING = (1u << 1), /**< executable object is currently running */
+  /* Generator specific flags. */
+  ECMA_GENERATOR_ITERATE_AND_YIELD = (1u << 2), /**< the generator performs a yield* operation */
+} ecma_executable_object_flags_t;
+
+/**
+ * Checks whether the executable object is waiting for resuming.
+ */
+#define ECMA_EXECUTABLE_OBJECT_IS_SUSPENDED(extra_info) \
+  (!((extra_info) & (ECMA_EXECUTABLE_OBJECT_COMPLETED | ECMA_EXECUTABLE_OBJECT_RUNNING)))
+
+#endif /* ENABLED (JERRY_ES2015) */
+
 #if ENABLED (JERRY_ES2015_BUILTIN_DATAVIEW)
 /**
  * Description of DataView objects.

jerry-core/ecma/base/ecma-helpers-conversion.c

@@ -280,13 +280,87 @@ static const uint8_t ecma_uint4_clz[] = { 4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0,
  */
 #define EPSILON 0.0000001
 
+/**
+ * ECMA-defined conversion from string to number for different radixes (2, 8, 16).
+ *
+ * See also:
+ *          ECMA-262 v5 9.3.1
+ *          ECMA-262 v6 7.1.3.1
+ *
+ * @return NaN - if the conversion fails
+ *         converted number - otherwise
+ */
+static ecma_number_t
+ecma_utf8_string_to_number_by_radix (const lit_utf8_byte_t *str_p, /**< utf-8 string */
+                                     const lit_utf8_byte_t *end_p, /**< end of utf-8 string  */
+                                     uint32_t radix) /**< radix */
+{
+  JERRY_ASSERT (radix == 2 || radix == 8 || radix == 16);
+  ecma_number_t num = ECMA_NUMBER_ZERO;
+
+#if ENABLED (JERRY_ES2015)
+  if (radix <= 8)
+  {
+    lit_code_point_t upper_limit = LIT_CHAR_0 + radix;
+
+    for (const lit_utf8_byte_t * iter_p = str_p;  iter_p <= end_p; iter_p++)
+    {
+      int32_t digit_value;
+
+      if (*iter_p >= LIT_CHAR_0 && *iter_p < upper_limit)
+      {
+        digit_value = (*iter_p - LIT_CHAR_0);
+      }
+      else
+      {
+        return ecma_number_make_nan ();
+      }
+
+      num = num * radix + (ecma_number_t) digit_value;
+    }
+
+    return num;
+  }
+#endif /* ENABLED (JERRY_ES2015) */
+
+  for (const lit_utf8_byte_t * iter_p = str_p; iter_p <= end_p; iter_p++)
+  {
+    int32_t digit_value;
+
+    if (*iter_p >= LIT_CHAR_0
+        && *iter_p <= LIT_CHAR_9)
+    {
+      digit_value = (*iter_p - LIT_CHAR_0);
+    }
+    else if (*iter_p >= LIT_CHAR_LOWERCASE_A
+            && *iter_p <= LIT_CHAR_LOWERCASE_F)
+    {
+      digit_value = 10 + (*iter_p - LIT_CHAR_LOWERCASE_A);
+    }
+    else if (*iter_p >= LIT_CHAR_UPPERCASE_A
+            && *iter_p <= LIT_CHAR_UPPERCASE_F)
+    {
+      digit_value = 10 + (*iter_p - LIT_CHAR_UPPERCASE_A);
+    }
+    else
+    {
+      return ecma_number_make_nan ();
+    }
+
+    num = num * radix + (ecma_number_t) digit_value;
+  }
+
+  return num;
+} /* ecma_utf8_string_to_number_by_radix */
+
 /**
  * ECMA-defined conversion of string to Number.
  *
  * See also:
  *          ECMA-262 v5, 9.3.1
  *
- * @return ecma-number
+ * @return NaN - if the conversion fails
+ *         converted number - otherwise
  */
 ecma_number_t
 ecma_utf8_string_to_number (const lit_utf8_byte_t *str_p, /**< utf-8 string */
@@ -307,46 +381,28 @@ ecma_utf8_string_to_number (const lit_utf8_byte_t *str_p, /**< utf-8 string */
     return ECMA_NUMBER_ZERO;
   }
 
-  if ((end_p >= str_p + 2)
-      && str_p[0] == LIT_CHAR_0
-      && (str_p[1] == LIT_CHAR_LOWERCASE_X
-          || str_p[1] == LIT_CHAR_UPPERCASE_X))
+  if (end_p >= str_p + 2
+      && str_p[0] == LIT_CHAR_0)
   {
-    /* Hex literal handling */
-    str_p += 2;
-
-    ecma_number_t num = ECMA_NUMBER_ZERO;
-
-    for (const lit_utf8_byte_t * iter_p = str_p;
-         iter_p <= end_p;
-         iter_p++)
+    switch (LEXER_TO_ASCII_LOWERCASE (str_p[1]))
     {
-      int32_t digit_value;
-
-      if (*iter_p >= LIT_CHAR_0
-          && *iter_p <= LIT_CHAR_9)
+      case LIT_CHAR_LOWERCASE_X :
       {
-        digit_value = (*iter_p - LIT_CHAR_0);
+        return ecma_utf8_string_to_number_by_radix (str_p + 2, end_p, 16);
       }
-      else if (*iter_p >= LIT_CHAR_LOWERCASE_A
-               && *iter_p <= LIT_CHAR_LOWERCASE_F)
+      case LIT_CHAR_LOWERCASE_O :
       {
-        digit_value = 10 + (*iter_p - LIT_CHAR_LOWERCASE_A);
+        return ecma_utf8_string_to_number_by_radix (str_p + 2, end_p, 8);
       }
-      else if (*iter_p >= LIT_CHAR_UPPERCASE_A
-               && *iter_p <= LIT_CHAR_UPPERCASE_F)
+      case LIT_CHAR_LOWERCASE_B :
       {
-        digit_value = 10 + (*iter_p - LIT_CHAR_UPPERCASE_A);
+        return ecma_utf8_string_to_number_by_radix (str_p + 2, end_p, 2);
       }
-      else
+      default:
       {
-        return ecma_number_make_nan ();
+        break;
       }
-
-      num = num * 16 + (ecma_number_t) digit_value;
     }
-
-    return num;
   }
 
   bool sign = false; /* positive */
@@ -703,9 +759,7 @@ ecma_uint32_to_utf8_string (uint32_t value, /**< value to convert */
 uint32_t
 ecma_number_to_uint32 (ecma_number_t num) /**< ecma-number */
 {
-  if (ecma_number_is_nan (num)
-      || ecma_number_is_zero (num)
-      || ecma_number_is_infinity (num))
+  if (JERRY_UNLIKELY (ecma_number_is_zero (num) || !ecma_number_is_finite (num)))
   {
     return 0;
   }

jerry-core/ecma/base/ecma-helpers-external-pointers.c

@@ -39,8 +39,7 @@ ecma_create_native_pointer_property (ecma_object_t *obj_p, /**< object to create
 {
   ecma_string_t *name_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER);
 
-  if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY
-      && ((ecma_extended_object_t *) obj_p)->u.array.is_fast_mode)
+  if (ecma_op_object_is_fast_array (obj_p))
   {
     ecma_fast_array_convert_to_normal (obj_p);
   }
@@ -115,8 +114,7 @@ ecma_native_pointer_t *
 ecma_get_native_pointer_value (ecma_object_t *obj_p, /**< object to get property value from */
                                void *info_p) /**< native pointer's type info */
 {
-  if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY
-      && ((ecma_extended_object_t *) obj_p)->u.array.is_fast_mode)
+  if (ecma_op_object_is_fast_array (obj_p))
   {
     /* Fast access mode array can not have native pointer properties */
     return NULL;
@@ -164,8 +162,7 @@ bool
 ecma_delete_native_pointer_property (ecma_object_t *obj_p, /**< object to delete property from */
                                      void *info_p) /**< native pointer's type info */
 {
-  if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY
-      && ((ecma_extended_object_t *) obj_p)->u.array.is_fast_mode)
+  if (ecma_op_object_is_fast_array (obj_p))
   {
     /* Fast access mode array can not have native pointer properties */
     return false;

jerry-core/ecma/base/ecma-helpers-number.c

@@ -298,8 +298,6 @@ ecma_number_is_negative (ecma_number_t num) /**< ecma-number */
 bool
 ecma_number_is_zero (ecma_number_t num) /**< ecma-number */
 {
-  JERRY_ASSERT (!ecma_number_is_nan (num));
-
   bool is_zero = (num == ECMA_NUMBER_ZERO);
 
 #ifndef JERRY_NDEBUG
@@ -323,8 +321,6 @@ ecma_number_is_zero (ecma_number_t num) /**< ecma-number */
 bool
 ecma_number_is_infinity (ecma_number_t num) /**< ecma-number */
 {
-  JERRY_ASSERT (!ecma_number_is_nan (num));
-
   uint32_t biased_exp = ecma_number_get_biased_exponent_field (num);
   uint64_t fraction = ecma_number_get_fraction_field (num);
 
@@ -333,6 +329,24 @@ ecma_number_is_infinity (ecma_number_t num) /**< ecma-number */
           && (fraction == 0));
 } /* ecma_number_is_infinity */
 
+/**
+ * Check if number is finite
+ *
+ * @return true  - if number is finite
+ *         false - if number is NaN or infinity
+ */
+extern inline bool JERRY_ATTR_ALWAYS_INLINE
+ecma_number_is_finite (ecma_number_t num) /**< ecma-number */
+{
+#if defined (__GNUC__) || defined (__clang__)
+  return __builtin_isfinite (num);
+#elif defined (WIN32)
+  return isfinite (num);
+#else
+  return !ecma_number_is_nan (num) && !ecma_number_is_infinity (num);
+#endif /* defined (__GNUC__) || defined (__clang__) */
+} /* ecma_number_is_finite */
+
 /**
  * Get fraction and exponent of the number
  *

jerry-core/ecma/base/ecma-helpers-string.c

@@ -204,7 +204,7 @@ ecma_new_ecma_string_from_magic_string_ex_id (lit_magic_string_ex_id_t id) /**<
   return string_desc_p;
 } /* ecma_new_ecma_string_from_magic_string_ex_id */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /**
  * Allocate new ecma-string and fill it with reference to the symbol descriptor
  *
@@ -238,7 +238,7 @@ ecma_prop_name_is_symbol (ecma_string_t *string_p) /**< ecma-string */
   return (!ECMA_IS_DIRECT_STRING (string_p)
           && ECMA_STRING_GET_CONTAINER (string_p) == ECMA_STRING_CONTAINER_SYMBOL);
 } /* ecma_prop_name_is_symbol */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #if ENABLED (JERRY_ES2015_BUILTIN_MAP) || ENABLED (JERRY_ES2015_BUILTIN_SET)
 /**
@@ -461,16 +461,9 @@ ecma_new_ecma_string_from_utf8_converted_to_cesu8 (const lit_utf8_byte_t *string
     if ((string_p[pos] & LIT_UTF8_4_BYTE_MASK) == LIT_UTF8_4_BYTE_MARKER)
     {
       /* Processing 4 byte unicode sequence. Always converted to two 3 byte long sequence. */
-      uint32_t character = ((((uint32_t) string_p[pos++]) & 0x7) << 18);
-      character |= ((((uint32_t) string_p[pos++]) & LIT_UTF8_LAST_6_BITS_MASK) << 12);
-      character |= ((((uint32_t) string_p[pos++]) & LIT_UTF8_LAST_6_BITS_MASK) << 6);
-      character |= (((uint32_t) string_p[pos++]) & LIT_UTF8_LAST_6_BITS_MASK);
-
-      JERRY_ASSERT (character >= 0x10000);
-      character -= 0x10000;
-
-      data_p += lit_char_to_utf8_bytes (data_p, (ecma_char_t) (0xd800 | (character >> 10)));
-      data_p += lit_char_to_utf8_bytes (data_p, (ecma_char_t) (0xdc00 | (character & LIT_UTF16_LAST_10_BITS_MASK)));
+      lit_four_byte_utf8_char_to_cesu8 (data_p, string_p + pos);
+      data_p += 3 * 2;
+      pos += 4;
     }
     else
     {
@@ -499,7 +492,8 @@ ecma_new_ecma_string_from_code_unit (ecma_char_t code_unit) /**< code unit */
   return ecma_new_ecma_string_from_utf8 (lit_utf8_bytes, bytes_size);
 } /* ecma_new_ecma_string_from_code_unit */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * Allocate new ecma-string and fill it with cesu-8 character which represents specified code units
  *
@@ -515,7 +509,8 @@ ecma_new_ecma_string_from_code_units (ecma_char_t first_code_unit, /**< code uni
 
   return ecma_new_ecma_string_from_utf8 (lit_utf8_bytes, bytes_size);
 } /* ecma_new_ecma_string_from_code_units */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Allocate new ecma-string and fill it with ecma-number
@@ -681,7 +676,6 @@ ecma_append_chars_to_string (ecma_string_t *string1_p, /**< base ecma-string */
                                                    cesu8_string2_p,
                                                    cesu8_string2_size);
 
-
   if (magic_string_id != LIT_MAGIC_STRING__COUNT)
   {
     ecma_deref_ecma_string (string1_p);
@@ -910,7 +904,7 @@ ecma_destroy_ecma_string (ecma_string_t *string_p) /**< ecma-string */
                                   ((ecma_ascii_string_t *) string_p)->size + sizeof (ecma_ascii_string_t));
       return;
     }
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
     case ECMA_STRING_CONTAINER_SYMBOL:
     {
       ecma_extended_string_t * symbol_p = (ecma_extended_string_t *) string_p;
@@ -918,7 +912,7 @@ ecma_destroy_ecma_string (ecma_string_t *string_p) /**< ecma-string */
       ecma_dealloc_extended_string (symbol_p);
       return;
     }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 #if ENABLED (JERRY_ES2015_BUILTIN_MAP) || ENABLED (JERRY_ES2015_BUILTIN_SET)
     case ECMA_STRING_CONTAINER_MAP_KEY:
     {
@@ -1809,12 +1803,12 @@ ecma_compare_ecma_strings (const ecma_string_t *string1_p, /**< ecma-string */
     return true;
   }
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   if (string1_container == ECMA_STRING_CONTAINER_SYMBOL)
   {
     return false;
   }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #if ENABLED (JERRY_ES2015_BUILTIN_MAP)
   if (string1_container == ECMA_STRING_CONTAINER_MAP_KEY)
@@ -1863,12 +1857,12 @@ ecma_compare_ecma_non_direct_strings (const ecma_string_t *string1_p, /**< ecma-
     return true;
   }
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   if (string1_container == ECMA_STRING_CONTAINER_SYMBOL)
   {
     return false;
   }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #if ENABLED (JERRY_ES2015_BUILTIN_MAP)
   if (string1_container == ECMA_STRING_CONTAINER_MAP_KEY)
@@ -2681,10 +2675,10 @@ void
 ecma_stringbuilder_append_char (ecma_stringbuilder_t *builder_p, /**< string builder */
                                 const ecma_char_t c) /**< ecma char */
 {
-  const lit_utf8_size_t size = (lit_utf8_size_t) lit_char_get_utf8_length (c);
+  const lit_utf8_size_t size = (lit_utf8_size_t) lit_code_point_get_cesu8_length (c);
   lit_utf8_byte_t *dest_p = ecma_stringbuilder_grow (builder_p, size);
 
-  lit_char_to_utf8_bytes (dest_p, c);
+  lit_code_point_to_cesu8_bytes (dest_p, c);
 } /* ecma_stringbuilder_append_char */
 
 /**
@@ -2799,6 +2793,58 @@ ecma_stringbuilder_destroy (ecma_stringbuilder_t *builder_p) /**< string builder
 #endif /* ENABLED (JERRY_MEM_STATS) */
 } /* ecma_stringbuilder_destroy */
 
+#if ENABLED (JERRY_ES2015)
+/**
+ * AdvanceStringIndex operation
+ *
+ * See also:
+ *          ECMA-262 v6.0, 21.2.5.2.3
+ *
+ * @return uint32_t - the proper character index based on the operation
+ */
+uint32_t
+ecma_op_advance_string_index (ecma_string_t *str_p, /**< input string */
+                              uint32_t index, /**< given character index */
+                              bool is_unicode) /**< true - if regexp object's "unicode" flag is set
+                                                    false - otherwise */
+{
+  if (index >= UINT32_MAX - 1)
+  {
+    return UINT32_MAX;
+  }
+
+  uint32_t next_index = index + 1;
+
+  if (!is_unicode)
+  {
+    return next_index;
+  }
+
+  ecma_length_t str_len = ecma_string_get_length (str_p);
+
+  if (next_index >= str_len)
+  {
+    return next_index;
+  }
+
+  ecma_char_t first = ecma_string_get_char_at_pos (str_p, index);
+
+  if (first < LIT_UTF16_HIGH_SURROGATE_MIN || first > LIT_UTF16_HIGH_SURROGATE_MAX)
+  {
+    return next_index;
+  }
+
+  ecma_char_t second = ecma_string_get_char_at_pos (str_p, next_index);
+
+  if (second < LIT_UTF16_LOW_SURROGATE_MIN || second > LIT_UTF16_LOW_SURROGATE_MAX)
+  {
+    return next_index;
+  }
+
+  return next_index + 1;
+} /* ecma_op_advance_string_index */
+#endif /* ENABLED (JERRY_ES2015) */
+
 /**
  * @}
  * @}

jerry-core/ecma/base/ecma-helpers-value.c

@@ -63,7 +63,7 @@ JERRY_STATIC_ASSERT ((ECMA_VALUE_FALSE | (1 << ECMA_DIRECT_SHIFT)) == ECMA_VALUE
  *
  * @return type field
  */
-static inline ecma_type_t JERRY_ATTR_CONST JERRY_ATTR_ALWAYS_INLINE
+extern inline ecma_type_t JERRY_ATTR_CONST JERRY_ATTR_ALWAYS_INLINE
 ecma_get_value_type_field (ecma_value_t value) /**< ecma value */
 {
   return value & ECMA_VALUE_TYPE_MASK;
@@ -311,7 +311,7 @@ ecma_is_value_string (ecma_value_t value) /**< ecma value */
   return ((value & (ECMA_VALUE_TYPE_MASK - 0x4)) == ECMA_TYPE_STRING);
 } /* ecma_is_value_string */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /**
  * Check if the value is symbol.
  *
@@ -323,7 +323,7 @@ ecma_is_value_symbol (ecma_value_t value) /**< ecma value */
 {
   return (ecma_get_value_type_field (value) == ECMA_TYPE_SYMBOL);
 } /* ecma_is_value_symbol */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Check if the value can be property name.
@@ -334,11 +334,11 @@ ecma_is_value_symbol (ecma_value_t value) /**< ecma value */
 inline bool JERRY_ATTR_CONST JERRY_ATTR_ALWAYS_INLINE
 ecma_is_value_prop_name (ecma_value_t value) /**< ecma value */
 {
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   return ecma_is_value_string (value) || ecma_is_value_symbol (value);
-#else /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#else /* !ENABLED (JERRY_ES2015) */
   return ecma_is_value_string (value);
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 } /* ecma_is_value_prop_name */
 
 /**
@@ -405,6 +405,19 @@ ecma_check_value_type_is_spec_defined (ecma_value_t value) /**< ecma value */
                 || ecma_is_value_object (value));
 } /* ecma_check_value_type_is_spec_defined */
 
+/**
+ * Checks if the given argument is an array or not.
+ *
+ * @return true - if the given argument is an array object
+ *         false - otherwise
+ */
+inline bool JERRY_ATTR_CONST JERRY_ATTR_ALWAYS_INLINE
+ecma_is_value_array (ecma_value_t arg) /**< argument */
+{
+  return (ecma_is_value_object (arg)
+          && ecma_get_object_type (ecma_get_object_from_value (arg)) == ECMA_OBJECT_TYPE_ARRAY);
+} /* ecma_is_value_array */
+
 /**
  * Creates an ecma value from the given raw boolean.
  *
@@ -547,9 +560,9 @@ inline ecma_value_t JERRY_ATTR_PURE JERRY_ATTR_ALWAYS_INLINE
 ecma_make_string_value (const ecma_string_t *ecma_string_p) /**< string to reference in value */
 {
   JERRY_ASSERT (ecma_string_p != NULL);
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   JERRY_ASSERT (!ecma_prop_name_is_symbol ((ecma_string_t *) ecma_string_p));
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
   if ((((uintptr_t) ecma_string_p) & ECMA_VALUE_TYPE_MASK) != 0)
   {
@@ -559,7 +572,7 @@ ecma_make_string_value (const ecma_string_t *ecma_string_p) /**< string to refer
   return ecma_pointer_to_ecma_value (ecma_string_p) | ECMA_TYPE_STRING;
 } /* ecma_make_string_value */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /**
  * Symbol value constructor
  *
@@ -573,7 +586,7 @@ ecma_make_symbol_value (const ecma_string_t *ecma_symbol_p) /**< symbol to refer
 
   return ecma_pointer_to_ecma_value (ecma_symbol_p) | ECMA_TYPE_SYMBOL;
 } /* ecma_make_symbol_value */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Property-name value constructor
@@ -585,12 +598,12 @@ ecma_make_prop_name_value (const ecma_string_t *ecma_prop_name_p) /**< property
 {
   JERRY_ASSERT (ecma_prop_name_p != NULL);
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   if (ecma_prop_name_is_symbol ((ecma_string_t *) ecma_prop_name_p))
   {
     return ecma_make_symbol_value (ecma_prop_name_p);
   }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
   return ecma_make_string_value (ecma_prop_name_p);
 } /* ecma_make_prop_name_value */
@@ -705,7 +718,7 @@ ecma_get_string_from_value (ecma_value_t value) /**< ecma value */
   return (ecma_string_t *) ecma_get_pointer_from_ecma_value (value);
 } /* ecma_get_string_from_value */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /**
  * Get pointer to ecma-string from ecma value
  *
@@ -718,7 +731,7 @@ ecma_get_symbol_from_value (ecma_value_t value) /**< ecma value */
 
   return (ecma_string_t *) ecma_get_pointer_from_ecma_value (value);
 } /* ecma_get_symbol_from_value */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Get pointer to a property name from ecma value
@@ -798,13 +811,13 @@ ecma_copy_value (ecma_value_t value)  /**< value description */
       ecma_ref_ecma_string (ecma_get_string_from_value (value));
       return value;
     }
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
     case ECMA_TYPE_SYMBOL:
     {
       ecma_ref_ecma_string (ecma_get_symbol_from_value (value));
       return value;
     }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
     case ECMA_TYPE_OBJECT:
     {
       ecma_ref_object (ecma_get_object_from_value (value));
@@ -842,10 +855,10 @@ ecma_fast_copy_value (ecma_value_t value)  /**< value description */
  *
  * @return copy of the given value
  */
-ecma_value_t
+inline ecma_value_t JERRY_ATTR_ALWAYS_INLINE
 ecma_copy_value_if_not_object (ecma_value_t value) /**< value description */
 {
-  if (ecma_get_value_type_field (value) != ECMA_TYPE_OBJECT)
+  if (!ecma_is_value_object (value))
   {
     return ecma_copy_value (value);
   }
@@ -853,6 +866,30 @@ ecma_copy_value_if_not_object (ecma_value_t value) /**< value description */
   return value;
 } /* ecma_copy_value_if_not_object */
 
+/**
+ * Increase reference counter of a value if it is an object.
+ */
+inline void JERRY_ATTR_ALWAYS_INLINE
+ecma_ref_if_object (ecma_value_t value) /**< value description */
+{
+  if (ecma_is_value_object (value))
+  {
+    ecma_ref_object (ecma_get_object_from_value (value));
+  }
+} /* ecma_ref_if_object */
+
+/**
+ * Decrease reference counter of a value if it is an object.
+ */
+inline void JERRY_ATTR_ALWAYS_INLINE
+ecma_deref_if_object (ecma_value_t value) /**< value description */
+{
+  if (ecma_is_value_object (value))
+  {
+    ecma_deref_object (ecma_get_object_from_value (value));
+  }
+} /* ecma_deref_if_object */
+
 /**
  * Assign a new value to an ecma-value
  *
@@ -995,13 +1032,13 @@ ecma_free_value (ecma_value_t value) /**< value description */
       ecma_deref_ecma_string (string_p);
       break;
     }
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
     case ECMA_TYPE_SYMBOL:
     {
       ecma_deref_ecma_string (ecma_get_symbol_from_value (value));
       break;
     }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
     case ECMA_TYPE_OBJECT:
     {
       ecma_deref_object (ecma_get_object_from_value (value));
@@ -1101,12 +1138,12 @@ ecma_get_typeof_lit_id (ecma_value_t value) /**< input ecma value */
   {
     ret_value = LIT_MAGIC_STRING_STRING;
   }
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   else if (ecma_is_value_symbol (value))
   {
     ret_value = LIT_MAGIC_STRING_SYMBOL;
   }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
   else
   {
     JERRY_ASSERT (ecma_is_value_object (value));

jerry-core/ecma/base/ecma-helpers.c

@@ -14,6 +14,7 @@
  */
 
 #include "ecma-alloc.h"
+#include "ecma-array-object.h"
 #include "ecma-gc.h"
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
@@ -54,8 +55,8 @@ JERRY_STATIC_ASSERT (ECMA_OBJECT_FLAG_EXTENSIBLE == (ECMA_OBJECT_FLAG_BUILT_IN_O
 JERRY_STATIC_ASSERT (ECMA_OBJECT_REF_ONE == (ECMA_OBJECT_FLAG_EXTENSIBLE << 1),
                      ecma_object_ref_one_must_follow_the_extensible_flag);
 
-JERRY_STATIC_ASSERT ((ECMA_OBJECT_MAX_REF | (ECMA_OBJECT_REF_ONE - 1)) == UINT16_MAX,
-                     ecma_object_max_ref_does_not_fill_the_remaining_bits);
+JERRY_STATIC_ASSERT (((ECMA_OBJECT_MAX_REF + ECMA_OBJECT_REF_ONE) | (ECMA_OBJECT_REF_ONE - 1)) == UINT16_MAX,
+                      ecma_object_max_ref_does_not_fill_the_remaining_bits);
 
 JERRY_STATIC_ASSERT (ECMA_PROPERTY_TYPE_DELETED == (ECMA_DIRECT_STRING_MAGIC << ECMA_PROPERTY_NAME_TYPE_SHIFT),
                      ecma_property_type_deleted_must_have_magic_string_name_type);
@@ -138,12 +139,12 @@ ecma_create_object_lex_env (ecma_object_t *outer_lexical_environment_p, /**< out
                             ecma_object_t *binding_obj_p, /**< binding object */
                             ecma_lexical_environment_type_t type) /**< type of the new lexical environment */
 {
-#if ENABLED (JERRY_ES2015_CLASS)
+#if ENABLED (JERRY_ES2015)
   JERRY_ASSERT (type == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND
                 || type == ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND);
-#else /* !ENABLED (JERRY_ES2015_CLASS) */
+#else /* !ENABLED (JERRY_ES2015) */
   JERRY_ASSERT (type == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND);
-#endif /* ENABLED (JERRY_ES2015_CLASS) */
+#endif /* ENABLED (JERRY_ES2015) */
 
   JERRY_ASSERT (binding_obj_p != NULL
                 && !ecma_is_lexical_environment (binding_obj_p));
@@ -308,16 +309,86 @@ ecma_get_lex_env_binding_object (const ecma_object_t *object_p) /**< object-boun
 {
   JERRY_ASSERT (object_p != NULL);
   JERRY_ASSERT (ecma_is_lexical_environment (object_p));
-#if ENABLED (JERRY_ES2015_CLASS)
+#if ENABLED (JERRY_ES2015)
   JERRY_ASSERT (ecma_get_lex_env_type (object_p) == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND
                 || ecma_get_lex_env_type (object_p) == ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND);
-#else /* !ENABLED (JERRY_ES2015_CLASS) */
+#else /* !ENABLED (JERRY_ES2015) */
   JERRY_ASSERT (ecma_get_lex_env_type (object_p) == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND);
-#endif /* ENABLED (JERRY_ES2015_CLASS) */
+#endif /* ENABLED (JERRY_ES2015) */
 
   return ECMA_GET_NON_NULL_POINTER (ecma_object_t, object_p->u1.bound_object_cp);
 } /* ecma_get_lex_env_binding_object */
 
+/**
+ * Create a new lexical environment with the same property list as the passed lexical environment
+ *
+ * @return pointer to the newly created lexical environment
+ */
+ecma_object_t *
+ecma_clone_decl_lexical_environment (ecma_object_t *lex_env_p, /**< declarative lexical environment */
+                                     bool copy_values) /**< copy property values as well */
+{
+  JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE);
+  JERRY_ASSERT (lex_env_p->u2.outer_reference_cp != JMEM_CP_NULL);
+
+  ecma_object_t *outer_lex_env_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t, lex_env_p->u2.outer_reference_cp);
+  ecma_object_t *new_lex_env_p = ecma_create_decl_lex_env (outer_lex_env_p);
+
+  jmem_cpointer_t prop_iter_cp = lex_env_p->u1.property_list_cp;
+  JERRY_ASSERT (prop_iter_cp != JMEM_CP_NULL);
+
+  ecma_property_header_t *prop_iter_p = ECMA_GET_NON_NULL_POINTER (ecma_property_header_t,
+                                                                   prop_iter_cp);
+  if (prop_iter_p->types[0] == ECMA_PROPERTY_TYPE_HASHMAP)
+  {
+    prop_iter_cp = prop_iter_p->next_property_cp;
+  }
+
+  JERRY_ASSERT (prop_iter_cp != JMEM_CP_NULL);
+
+  do
+  {
+    prop_iter_p = ECMA_GET_NON_NULL_POINTER (ecma_property_header_t, prop_iter_cp);
+
+    JERRY_ASSERT (ECMA_PROPERTY_IS_PROPERTY_PAIR (prop_iter_p));
+
+    ecma_property_pair_t *prop_pair_p = (ecma_property_pair_t *) prop_iter_p;
+
+    for (int i = 0; i < ECMA_PROPERTY_PAIR_ITEM_COUNT; i++)
+    {
+      if (prop_iter_p->types[i] != ECMA_PROPERTY_TYPE_DELETED)
+      {
+        JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (prop_iter_p->types[i]) == ECMA_PROPERTY_TYPE_NAMEDDATA);
+
+        uint8_t prop_attributes = (uint8_t) (prop_iter_p->types[i] & ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
+        ecma_string_t *name_p = ecma_string_from_property_name (prop_iter_p->types[i], prop_pair_p->names_cp[i]);
+
+        ecma_property_value_t *property_value_p;
+        property_value_p = ecma_create_named_data_property (new_lex_env_p, name_p, prop_attributes, NULL);
+
+        ecma_deref_ecma_string (name_p);
+
+        JERRY_ASSERT (property_value_p->value == ECMA_VALUE_UNDEFINED);
+
+        if (copy_values)
+        {
+          property_value_p->value = ecma_copy_value_if_not_object (prop_pair_p->values[i].value);
+        }
+        else
+        {
+          property_value_p->value = ECMA_VALUE_UNINITIALIZED;
+        }
+      }
+    }
+
+    prop_iter_cp = prop_iter_p->next_property_cp;
+  }
+  while (prop_iter_cp != JMEM_CP_NULL);
+
+  ecma_deref_object (lex_env_p);
+  return new_lex_env_p;
+} /* ecma_clone_decl_lexical_environment */
+
 /**
  * Create a property in an object and link it into
  * the object's properties' linked-list (at start of the list).
@@ -473,8 +544,7 @@ ecma_create_named_data_property (ecma_object_t *object_p, /**< object */
 {
   JERRY_ASSERT (object_p != NULL && name_p != NULL);
   JERRY_ASSERT (ecma_is_lexical_environment (object_p)
-              || ecma_get_object_type (object_p) != ECMA_OBJECT_TYPE_ARRAY
-              || !((ecma_extended_object_t *) object_p)->u.array.is_fast_mode);
+                || !ecma_op_object_is_fast_array (object_p));
   JERRY_ASSERT (ecma_find_named_property (object_p, name_p) == NULL);
   JERRY_ASSERT ((prop_attributes & ~ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE) == 0);
 
@@ -502,8 +572,7 @@ ecma_create_named_accessor_property (ecma_object_t *object_p, /**< object */
 {
   JERRY_ASSERT (object_p != NULL && name_p != NULL);
   JERRY_ASSERT (ecma_is_lexical_environment (object_p)
-              || ecma_get_object_type (object_p) != ECMA_OBJECT_TYPE_ARRAY
-              || !((ecma_extended_object_t *) object_p)->u.array.is_fast_mode);
+                || !ecma_op_object_is_fast_array (object_p));
   JERRY_ASSERT (ecma_find_named_property (object_p, name_p) == NULL);
   JERRY_ASSERT ((prop_attributes & ~ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE) == 0);
 
@@ -537,8 +606,7 @@ ecma_find_named_property (ecma_object_t *obj_p, /**< object to find property in
   JERRY_ASSERT (obj_p != NULL);
   JERRY_ASSERT (name_p != NULL);
   JERRY_ASSERT (ecma_is_lexical_environment (obj_p)
-                || ecma_get_object_type (obj_p) != ECMA_OBJECT_TYPE_ARRAY
-                || !((ecma_extended_object_t *) obj_p)->u.array.is_fast_mode);
+                || !ecma_op_object_is_fast_array (obj_p));
 
   ecma_property_t *property_p = NULL;
 
@@ -696,8 +764,7 @@ ecma_get_named_data_property (ecma_object_t *obj_p, /**< object to find property
   JERRY_ASSERT (obj_p != NULL);
   JERRY_ASSERT (name_p != NULL);
   JERRY_ASSERT (ecma_is_lexical_environment (obj_p)
-                || ecma_get_object_type (obj_p) != ECMA_OBJECT_TYPE_ARRAY
-                || !((ecma_extended_object_t *) obj_p)->u.array.is_fast_mode);
+                || !ecma_op_object_is_fast_array (obj_p));
 
   ecma_property_t *property_p = ecma_find_named_property (obj_p, name_p);
 
@@ -1202,8 +1269,13 @@ ecma_create_error_reference (ecma_value_t value, /**< referenced value */
 ecma_value_t
 ecma_create_error_reference_from_context (void)
 {
-  return ecma_create_error_reference (JERRY_CONTEXT (error_value),
-                                      (JERRY_CONTEXT (status_flags) & ECMA_STATUS_EXCEPTION) != 0);
+  bool is_abort = jcontext_has_pending_abort ();
+
+  if (is_abort)
+  {
+    jcontext_set_abort_flag (false);
+  }
+  return ecma_create_error_reference (jcontext_take_exception (), !is_abort);
 } /* ecma_create_error_reference_from_context */
 
 /**
@@ -1254,40 +1326,35 @@ ecma_deref_error_reference (ecma_error_reference_t *error_ref_p) /**< error refe
 } /* ecma_deref_error_reference */
 
 /**
- * Clears error reference, and returns with the value.
+ * Raise error from the given error reference.
  *
- * @return value referenced by the error
+ * Note: the error reference's ref count is also decreased
  */
-ecma_value_t
-ecma_clear_error_reference (ecma_value_t value, /**< error reference */
-                            bool set_abort_flag) /**< set abort flag */
+void
+ecma_raise_error_from_error_reference (ecma_value_t value) /**< error reference */
 {
+  JERRY_ASSERT (!jcontext_has_pending_exception () && !jcontext_has_pending_abort ());
   ecma_error_reference_t *error_ref_p = ecma_get_error_reference_from_value (value);
 
-  if (set_abort_flag)
-  {
-    if (error_ref_p->refs_and_flags & ECMA_ERROR_REF_ABORT)
-    {
-      JERRY_CONTEXT (status_flags) &= (uint32_t) ~ECMA_STATUS_EXCEPTION;
-    }
-    else
-    {
-      JERRY_CONTEXT (status_flags) |= ECMA_STATUS_EXCEPTION;
-    }
-  }
-
   JERRY_ASSERT (error_ref_p->refs_and_flags >= ECMA_ERROR_REF_ONE);
 
+  ecma_value_t referenced_value = error_ref_p->value;
+
+  jcontext_set_exception_flag (true);
+  jcontext_set_abort_flag (error_ref_p->refs_and_flags & ECMA_ERROR_REF_ABORT);
+
   if (error_ref_p->refs_and_flags >= 2 * ECMA_ERROR_REF_ONE)
   {
     error_ref_p->refs_and_flags -= ECMA_ERROR_REF_ONE;
-    return ecma_copy_value (error_ref_p->value);
+    referenced_value = ecma_copy_value (referenced_value);
+  }
+  else
+  {
+    jmem_pools_free (error_ref_p, sizeof (ecma_error_reference_t));
   }
 
-  ecma_value_t referenced_value = error_ref_p->value;
-  jmem_pools_free (error_ref_p, sizeof (ecma_error_reference_t));
-  return referenced_value;
-} /* ecma_clear_error_reference */
+  JERRY_CONTEXT (error_value) = referenced_value;
+} /* ecma_raise_error_from_error_reference */
 
 /**
  * Increase reference counter of Compact
@@ -1394,6 +1461,23 @@ ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p) /**< byte code pointer */
     }
 #endif /* ENABLED (JERRY_DEBUGGER) */
 
+#if ENABLED (JERRY_ES2015)
+    if (bytecode_p->status_flags & CBC_CODE_FLAG_HAS_TAGGED_LITERALS)
+    {
+      ecma_length_t formal_params_number = ecma_compiled_code_get_formal_params (bytecode_p);
+
+      uint8_t *byte_p = (uint8_t *) bytecode_p;
+      byte_p += ((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG;
+
+      ecma_value_t *tagged_base_p = (ecma_value_t *) byte_p;
+      tagged_base_p -= formal_params_number;
+
+      ecma_collection_t *coll_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_collection_t, tagged_base_p[-1]);
+
+      ecma_collection_destroy (coll_p);
+    }
+#endif /* ENABLED (JERRY_ES2015) */
+
 #if ENABLED (JERRY_MEM_STATS)
     jmem_stats_free_byte_code_bytes (((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG);
 #endif /* ENABLED (JERRY_MEM_STATS) */
@@ -1411,6 +1495,51 @@ ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p) /**< byte code pointer */
                         ((size_t) bytecode_p->size) << JMEM_ALIGNMENT_LOG);
 } /* ecma_bytecode_deref */
 
+#if ENABLED (JERRY_ES2015)
+/**
+ * Get the tagged template collection of the compiled code
+ *
+ * @return pointer to the tagged template collection
+ */
+ecma_collection_t *
+ecma_compiled_code_get_tagged_template_collection (const ecma_compiled_code_t *bytecode_header_p) /**< compiled code */
+{
+  JERRY_ASSERT (bytecode_header_p != NULL);
+  JERRY_ASSERT (bytecode_header_p->status_flags & CBC_CODE_FLAG_HAS_TAGGED_LITERALS);
+
+  uint8_t *byte_p = (uint8_t *) bytecode_header_p;
+  byte_p += ((size_t) bytecode_header_p->size) << JMEM_ALIGNMENT_LOG;
+
+  ecma_value_t *tagged_base_p = (ecma_value_t *) byte_p;
+  tagged_base_p -= ecma_compiled_code_get_formal_params (bytecode_header_p);
+
+  return ECMA_GET_INTERNAL_VALUE_POINTER (ecma_collection_t, tagged_base_p[-1]);
+} /* ecma_compiled_code_get_tagged_template_collection */
+#endif /* ENABLED (JERRY_ES2015) */
+
+#if ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM) || ENABLED (JERRY_ES2015)
+/**
+ * Get the number of formal parameters of the compiled code
+ *
+ * @return number of formal parameters
+ */
+ecma_length_t
+ecma_compiled_code_get_formal_params (const ecma_compiled_code_t *bytecode_header_p) /**< compiled code */
+{
+  if (!(bytecode_header_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED))
+  {
+    return 0;
+  }
+
+  if (bytecode_header_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS)
+  {
+    return ((cbc_uint16_arguments_t *) bytecode_header_p)->argument_end;
+  }
+
+  return ((cbc_uint8_arguments_t *) bytecode_header_p)->argument_end;
+} /* ecma_compiled_code_get_formal_params */
+#endif /* ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM) || ENABLED (JERRY_ES2015) */
+
 #if (JERRY_STACK_LIMIT != 0)
 /**
  * Check the current stack usage by calculating the difference from the initial stack base.

jerry-core/ecma/base/ecma-helpers.h

@@ -147,19 +147,20 @@ typedef enum
  */
 #define ECMA_BOOL_TO_BITFIELD(x) ((x) ? 1 : 0)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /**
  * JERRY_ASSERT compatible macro for checking whether the given ecma-value is symbol
  */
 #define ECMA_ASSERT_VALUE_IS_SYMBOL(value) (ecma_is_value_symbol ((value)))
-#else /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#else /* !ENABLED (JERRY_ES2015) */
 /**
  * JERRY_ASSERT compatible macro for checking whether the given ecma-value is symbol
  */
 #define ECMA_ASSERT_VALUE_IS_SYMBOL(value) (false)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* ecma-helpers-value.c */
+ecma_type_t JERRY_ATTR_CONST ecma_get_value_type_field (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_direct (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_simple (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_empty (ecma_value_t value);
@@ -176,14 +177,15 @@ bool JERRY_ATTR_CONST ecma_are_values_integer_numbers (ecma_value_t first_value,
 bool JERRY_ATTR_CONST ecma_is_value_float_number (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_number (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_string (ecma_value_t value);
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 bool JERRY_ATTR_CONST ecma_is_value_symbol (ecma_value_t value);
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 bool JERRY_ATTR_CONST ecma_is_value_prop_name (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_direct_string (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_non_direct_string (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_object (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_error_reference (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_array (ecma_value_t arg);
 
 void ecma_check_value_type_is_spec_defined (ecma_value_t value);
 
@@ -195,9 +197,9 @@ ecma_value_t ecma_make_number_value (ecma_number_t ecma_number);
 ecma_value_t ecma_make_int32_value (int32_t int32_number);
 ecma_value_t ecma_make_uint32_value (uint32_t uint32_number);
 ecma_value_t JERRY_ATTR_PURE ecma_make_string_value (const ecma_string_t *ecma_string_p);
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 ecma_value_t JERRY_ATTR_PURE ecma_make_symbol_value (const ecma_string_t *ecma_symbol_p);
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 ecma_value_t JERRY_ATTR_PURE ecma_make_prop_name_value (const ecma_string_t *ecma_prop_name_p);
 ecma_value_t JERRY_ATTR_PURE ecma_make_magic_string_value (lit_magic_string_id_t id);
 ecma_value_t JERRY_ATTR_PURE ecma_make_object_value (const ecma_object_t *object_p);
@@ -207,9 +209,9 @@ ecma_number_t JERRY_ATTR_PURE ecma_get_float_from_value (ecma_value_t value);
 ecma_number_t * ecma_get_pointer_from_float_value (ecma_value_t value);
 ecma_number_t JERRY_ATTR_PURE ecma_get_number_from_value (ecma_value_t value);
 ecma_string_t JERRY_ATTR_PURE *ecma_get_string_from_value (ecma_value_t value);
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 ecma_string_t JERRY_ATTR_PURE *ecma_get_symbol_from_value (ecma_value_t value);
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 ecma_string_t JERRY_ATTR_PURE *ecma_get_prop_name_from_value (ecma_value_t value);
 ecma_object_t JERRY_ATTR_PURE *ecma_get_object_from_value (ecma_value_t value);
 ecma_error_reference_t JERRY_ATTR_PURE *ecma_get_error_reference_from_value (ecma_value_t value);
@@ -217,6 +219,8 @@ ecma_value_t JERRY_ATTR_CONST ecma_invert_boolean_value (ecma_value_t value);
 ecma_value_t ecma_copy_value (ecma_value_t value);
 ecma_value_t ecma_fast_copy_value (ecma_value_t value);
 ecma_value_t ecma_copy_value_if_not_object (ecma_value_t value);
+void ecma_ref_if_object (ecma_value_t value);
+void ecma_deref_if_object (ecma_value_t value);
 ecma_value_t ecma_update_float_number (ecma_value_t float_value, ecma_number_t new_number);
 void ecma_value_assign_value (ecma_value_t *value_p, ecma_value_t ecma_value);
 void ecma_value_assign_number (ecma_value_t *value_p, ecma_number_t ecma_number);
@@ -227,10 +231,11 @@ void ecma_free_number (ecma_value_t value);
 lit_magic_string_id_t ecma_get_typeof_lit_id (ecma_value_t value);
 
 /* ecma-helpers-string.c */
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 ecma_string_t *ecma_new_symbol_from_descriptor_string (ecma_value_t string_desc);
 bool ecma_prop_name_is_symbol (ecma_string_t *string_p);
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+uint32_t ecma_op_advance_string_index (ecma_string_t *str_p, uint32_t index, bool is_unicode);
+#endif /* ENABLED (JERRY_ES2015) */
 #if ENABLED (JERRY_ES2015_BUILTIN_MAP) || ENABLED (JERRY_ES2015_BUILTIN_SET)
 ecma_string_t *ecma_new_map_key_string (ecma_value_t value);
 bool ecma_prop_name_is_map_key (ecma_string_t *string_p);
@@ -239,9 +244,9 @@ ecma_string_t *ecma_new_ecma_string_from_utf8 (const lit_utf8_byte_t *string_p,
 ecma_string_t *ecma_new_ecma_string_from_utf8_converted_to_cesu8 (const lit_utf8_byte_t *string_p,
                                                                   lit_utf8_size_t string_size);
 ecma_string_t *ecma_new_ecma_string_from_code_unit (ecma_char_t code_unit);
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
 ecma_string_t *ecma_new_ecma_string_from_code_units (ecma_char_t first_code_unit, ecma_char_t second_code_unit);
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 ecma_string_t *ecma_new_ecma_string_from_uint32 (uint32_t uint32_number);
 ecma_string_t *ecma_new_non_direct_string_from_uint32 (uint32_t uint32_number);
 ecma_string_t *ecma_get_ecma_string_from_uint32 (uint32_t uint32_number);
@@ -336,6 +341,7 @@ bool ecma_number_is_nan (ecma_number_t num);
 bool ecma_number_is_negative (ecma_number_t num);
 bool ecma_number_is_zero (ecma_number_t num);
 bool ecma_number_is_infinity (ecma_number_t num);
+bool ecma_number_is_finite (ecma_number_t num);
 ecma_number_t
 ecma_number_make_from_sign_mantissa_and_exponent (bool sign, uint64_t mantissa, int32_t exponent);
 ecma_number_t ecma_number_get_prev (ecma_number_t num);
@@ -371,6 +377,7 @@ uint8_t ecma_get_object_builtin_id (ecma_object_t *object_p);
 ecma_lexical_environment_type_t JERRY_ATTR_PURE ecma_get_lex_env_type (const ecma_object_t *object_p);
 ecma_object_t JERRY_ATTR_PURE *ecma_get_lex_env_outer_reference (const ecma_object_t *object_p);
 ecma_object_t JERRY_ATTR_PURE *ecma_get_lex_env_binding_object (const ecma_object_t *object_p);
+ecma_object_t *ecma_clone_decl_lexical_environment (ecma_object_t *lex_env_p, bool copy_values);
 
 ecma_property_value_t *
 ecma_create_named_data_property (ecma_object_t *object_p, ecma_string_t *name_p, uint8_t prop_attributes,
@@ -416,10 +423,16 @@ ecma_value_t ecma_create_error_reference_from_context (void);
 ecma_value_t ecma_create_error_object_reference (ecma_object_t *object_p);
 void ecma_ref_error_reference (ecma_error_reference_t *error_ref_p);
 void ecma_deref_error_reference (ecma_error_reference_t *error_ref_p);
-ecma_value_t ecma_clear_error_reference (ecma_value_t value, bool set_abort_flag);
+void ecma_raise_error_from_error_reference (ecma_value_t value);
 
 void ecma_bytecode_ref (ecma_compiled_code_t *bytecode_p);
 void ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p);
+#if ENABLED (JERRY_ES2015)
+ecma_collection_t *ecma_compiled_code_get_tagged_template_collection (const ecma_compiled_code_t *bytecode_header_p);
+#endif /* ENABLED (JERRY_ES2015) */
+#if ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM) || ENABLED (JERRY_ES2015)
+ecma_length_t ecma_compiled_code_get_formal_params (const ecma_compiled_code_t *bytecode_p);
+#endif /* ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ES2015_MODULE_SYSTEM) || ENABLED (JERRY_ES2015) */
 #if (JERRY_STACK_LIMIT != 0)
 uintptr_t ecma_get_current_stack_usage (void);
 #endif /* (JERRY_STACK_LIMIT != 0) */

jerry-core/ecma/base/ecma-init-finalize.c

@@ -29,12 +29,21 @@
  * @{
  */
 
+/**
+ * Maximum number of GC loops on cleanup.
+ */
+#define JERRY_GC_LOOP_LIMIT 100
+
 /**
  * Initialize ECMA components
  */
 void
 ecma_init (void)
 {
+#if (JERRY_GC_MARK_LIMIT != 0)
+  JERRY_CONTEXT (ecma_gc_mark_recursion_limit) = JERRY_GC_MARK_LIMIT;
+#endif /* (JERRY_GC_MARK_LIMIT != 0) */
+
   ecma_init_global_lex_env ();
 
 #if ENABLED (JERRY_PROPRETY_HASHMAP)
@@ -50,6 +59,11 @@ ecma_init (void)
 #if ENABLED (JERRY_ES2015_BUILTIN_PROMISE)
   ecma_job_queue_init ();
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
+
+#if ENABLED (JERRY_ES2015)
+  JERRY_CONTEXT (current_new_target) = JERRY_CONTEXT_INVALID_NEW_TARGET;
+  JERRY_CONTEXT (current_function_obj_p) = NULL;
+#endif /* ENABLED (JERRY_ES2015) */
 } /* ecma_init */
 
 /**
@@ -58,9 +72,23 @@ ecma_init (void)
 void
 ecma_finalize (void)
 {
+#if ENABLED (JERRY_ES2015)
+  JERRY_ASSERT (JERRY_CONTEXT (current_new_target) == JERRY_CONTEXT_INVALID_NEW_TARGET);
+  JERRY_ASSERT (JERRY_CONTEXT (current_function_obj_p) == NULL);
+#endif /* ENABLED (JERRY_ES2015) */
+
   ecma_finalize_global_lex_env ();
-  ecma_finalize_builtins ();
-  ecma_gc_run ();
+  uint8_t runs = 0;
+  do
+  {
+    ecma_finalize_builtins ();
+    ecma_gc_run ();
+    if (++runs >= JERRY_GC_LOOP_LIMIT)
+    {
+      jerry_fatal (ERR_UNTERMINATED_GC_LOOPS);
+    }
+  }
+  while (JERRY_CONTEXT (ecma_gc_new_objects) != 0);
   ecma_finalize_lit_storage ();
 } /* ecma_finalize */
 

jerry-core/ecma/base/ecma-literal-storage.c

@@ -25,7 +25,7 @@
  * @{
  */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /**
  * Free symbol list
  */
@@ -53,7 +53,7 @@ ecma_free_symbol_list (jmem_cpointer_t symbol_list_cp) /**< symbol list */
     symbol_list_cp = next_item_cp;
   }
 } /* ecma_free_symbol_list */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Free string list
@@ -115,9 +115,9 @@ ecma_free_number_list (jmem_cpointer_t number_list_cp) /**< string list */
 void
 ecma_finalize_lit_storage (void)
 {
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   ecma_free_symbol_list (JERRY_CONTEXT (symbol_list_first_cp));
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
   ecma_free_string_list (JERRY_CONTEXT (string_list_first_cp));
   ecma_free_number_list (JERRY_CONTEXT (number_list_first_cp));
 } /* ecma_finalize_lit_storage */
@@ -346,7 +346,7 @@ ecma_save_literals_add_compiled_code (const ecma_compiled_code_t *compiled_code_
     const_literal_end = args_p->const_literal_end - register_end;
     literal_end = args_p->literal_end - register_end;
 
-    if (CBC_NON_STRICT_ARGUMENTS_NEEDED (compiled_code_p))
+    if (compiled_code_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
     {
       argument_end = args_p->argument_end;
     }
@@ -361,7 +361,7 @@ ecma_save_literals_add_compiled_code (const ecma_compiled_code_t *compiled_code_
     const_literal_end = args_p->const_literal_end - register_end;
     literal_end = args_p->literal_end - register_end;
 
-    if (CBC_NON_STRICT_ARGUMENTS_NEEDED (compiled_code_p))
+    if (compiled_code_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
     {
       argument_end = args_p->argument_end;
     }

jerry-core/ecma/base/ecma-module.c

@@ -79,7 +79,6 @@ ecma_module_create_normalized_path (const uint8_t *char_p, /**< module specifier
                                                       ECMA_MODULE_MAX_PATH,
                                                       (char *) module_path_p);
 
-
   if (normalized_size > 0)
   {
     /* Convert the normalized path to cesu8. */
@@ -818,7 +817,7 @@ ecma_module_parse (ecma_module_t *module_p) /**< module */
                                                 0,
                                                 (jerry_char_t *) source_p,
                                                 source_size,
-                                                JERRY_PARSE_STRICT_MODE,
+                                                ECMA_PARSE_STRICT_MODE | ECMA_PARSE_MODULE,
                                                 &bytecode_data_p);
 
   JERRY_CONTEXT (module_top_context_p) = module_p->context_p->parent_p;

jerry-core/ecma/base/ecma-property-hashmap.c

@@ -245,7 +245,6 @@ ecma_property_hashmap_insert (ecma_object_t *object_p, /**< object */
   uint32_t mask = hashmap_p->max_property_count - 1;
   entry_index &= mask;
 
-
 #ifndef JERRY_NDEBUG
   /* See the comment for this variable in ecma_property_hashmap_create. */
   uint32_t start_entry_index = entry_index;

jerry-core/ecma/base/ecma-property-hashmap.h

@@ -72,7 +72,6 @@ void ecma_property_hashmap_insert (ecma_object_t *object_p, ecma_string_t *name_
 ecma_property_hashmap_delete_status ecma_property_hashmap_delete (ecma_object_t *object_p, jmem_cpointer_t name_cp,
                                                                   ecma_property_t *property_p);
 
-
 ecma_property_t *ecma_property_hashmap_find (ecma_property_hashmap_t *hashmap_p, ecma_string_t *name_p,
                                              jmem_cpointer_t *property_real_name_cp);
 #endif /* ENABLED (JERRY_PROPRETY_HASHMAP) */

jerry-core/ecma/builtin-objects/ecma-builtin-array-iterator-prototype.c

@@ -18,11 +18,7 @@
 #include "ecma-iterator-object.h"
 #include "ecma-typedarray-object.h"
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
-
-#if !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
-#error "Iterator builtin requires ES2015 symbol builtin"
-#endif /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#if ENABLED (JERRY_ES2015)
 
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"
@@ -82,40 +78,14 @@ ecma_builtin_array_iterator_prototype_object_next (ecma_value_t this_val) /**< t
 
   ecma_object_t *array_object_p = ecma_get_object_from_value (iterated_value);
 
-  uint32_t length;
-
   /* 8 - 9. */
-#if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
-  if (ecma_is_typedarray (ecma_make_object_value (array_object_p)))
+  uint32_t length;
+  ecma_value_t len_value = ecma_op_object_get_length (array_object_p, &length);
+
+  if (ECMA_IS_VALUE_ERROR (len_value))
   {
-    length = ecma_typedarray_get_length (array_object_p);
+    return len_value;
   }
-  else
-  {
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
-    ecma_value_t len_value = ecma_op_object_get (array_object_p,
-                                                 ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH));
-
-    if (ECMA_IS_VALUE_ERROR (len_value))
-    {
-      return len_value;
-    }
-
-    ecma_number_t length_number;
-    ecma_value_t length_value = ecma_get_number (len_value, &length_number);
-
-    if (ECMA_IS_VALUE_ERROR (length_value))
-    {
-      ecma_free_value (len_value);
-      return length_value;
-    }
-
-    length = ecma_number_to_uint32 (length_number);
-
-    ecma_free_value (len_value);
-#if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
-  }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
 
   uint32_t index = ext_obj_p->u.pseudo_array.u1.iterator_index;
 
@@ -161,12 +131,8 @@ ecma_builtin_array_iterator_prototype_object_next (ecma_value_t this_val) /**< t
     return ecma_create_iter_result_object (ecma_make_uint32_value (index), ECMA_VALUE_FALSE);
   }
 
-  /* 13. */
-  ecma_string_t *index_string_p = ecma_new_ecma_string_from_uint32 (index);
-
   /* 14. */
-  ecma_value_t get_value = ecma_op_object_get (array_object_p, index_string_p);
-  ecma_deref_ecma_string (index_string_p);
+  ecma_value_t get_value = ecma_op_object_get_by_uint32_index (array_object_p, index);
 
   /* 15. */
   if (ECMA_IS_VALUE_ERROR (get_value))
@@ -206,4 +172,4 @@ ecma_builtin_array_iterator_prototype_object_next (ecma_value_t this_val) /**< t
  * @}
  */
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-array-iterator-prototype.inc.h

@@ -19,7 +19,7 @@
 
 #include "ecma-builtin-helpers-macro-defines.inc.h"
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
 
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_ARRAY_ITERATOR_UL,
@@ -29,6 +29,6 @@ STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
 ROUTINE (LIT_MAGIC_STRING_NEXT, ecma_builtin_array_iterator_prototype_object_next, 0, 0)
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype-unscopables.c

@@ -0,0 +1,28 @@
+/* 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 "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+
+#if ENABLED (JERRY_ES2015)
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-array-prototype-unscopables.inc.h"
+#define BUILTIN_UNDERSCORED_ID array_prototype_unscopables
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype-unscopables.inc.h

@@ -0,0 +1,54 @@
+/* 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.
+ */
+
+/*
+ * Array.prototype[@@unscopables] built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if ENABLED (JERRY_ES2015)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_COPY_WITHIN,
+              ECMA_VALUE_TRUE,
+              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_ENTRIES,
+              ECMA_VALUE_TRUE,
+              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FILL,
+              ECMA_VALUE_TRUE,
+              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FIND,
+              ECMA_VALUE_TRUE,
+              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FIND_INDEX,
+              ECMA_VALUE_TRUE,
+              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_KEYS,
+              ECMA_VALUE_TRUE,
+              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_VALUES,
+              ECMA_VALUE_TRUE,
+              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+#endif /* ENABLED (JERRY_ES2015) */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.inc.h

@@ -29,6 +29,13 @@ OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR,
               ECMA_BUILTIN_ID_ARRAY,
               ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
 
+#if ENABLED (JERRY_ES2015)
+/* ECMA-262 v6, 22.1.3.31 */
+OBJECT_VALUE (LIT_GLOBAL_SYMBOL_UNSCOPABLES,
+              ECMA_BUILTIN_ID_ARRAY_PROTOTYPE_UNSCOPABLES,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+#endif /* ENABLED (JERRY_ES2015) */
+
 /* Number properties:
  *  (property name, object pointer getter) */
 
@@ -60,18 +67,18 @@ ROUTINE (LIT_MAGIC_STRING_FOR_EACH_UL, ECMA_ARRAY_PROTOTYPE_FOR_EACH, 2, 1)
 ROUTINE (LIT_MAGIC_STRING_MAP, ECMA_ARRAY_PROTOTYPE_MAP, 2, 1)
 ROUTINE (LIT_MAGIC_STRING_FILTER, ECMA_ARRAY_PROTOTYPE_FILTER, 2, 1)
 /* Note these 2 routines must be in this order */
-ROUTINE (LIT_MAGIC_STRING_REDUCE, ECMA_ARRAY_PROTOTYPE_REDUCE, NON_FIXED, 1)
-ROUTINE (LIT_MAGIC_STRING_REDUCE_RIGHT_UL, ECMA_ARRAY_PROTOTYPE_REDUCE_RIGHT, NON_FIXED, 1)
-#if ENABLED (JERRY_ES2015_BUILTIN)
+ROUTINE (LIT_MAGIC_STRING_REDUCE, ECMA_ARRAY_PROTOTYPE_REDUCE, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_REDUCE_RIGHT_UL, ECMA_ARRAY_PROTOTYPE_REDUCE_RIGHT, 2, 1)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_FIND, ECMA_ARRAY_PROTOTYPE_FIND, 2, 1)
 ROUTINE (LIT_MAGIC_STRING_FIND_INDEX, ECMA_ARRAY_PROTOTYPE_FIND_INDEX, 2, 1)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+ROUTINE (LIT_MAGIC_STRING_FILL, ECMA_ARRAY_PROTOTYPE_FILL, 3, 1)
+ROUTINE (LIT_MAGIC_STRING_COPY_WITHIN, ECMA_ARRAY_PROTOTYPE_COPY_WITHIN, NON_FIXED, 2)
 ROUTINE (LIT_MAGIC_STRING_ENTRIES, ECMA_ARRAY_PROTOTYPE_ENTRIES, 0, 0)
-ROUTINE (LIT_MAGIC_STRING_VALUES, ECMA_ARRAY_PROTOTYPE_VALUES, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_KEYS, ECMA_ARRAY_PROTOTYPE_KEYS, 0, 0)
-ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ECMA_ARRAY_PROTOTYPE_SYMBOL_ITERATOR, 0, 0)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+INTRINSIC_PROPERTY (LIT_MAGIC_STRING_VALUES, LIT_INTERNAL_MAGIC_STRING_ARRAY_PROTOTYPE_VALUES)
+INTRINSIC_PROPERTY (LIT_GLOBAL_SYMBOL_ITERATOR, LIT_INTERNAL_MAGIC_STRING_ARRAY_PROTOTYPE_VALUES)
+#endif /* ENABLED (JERRY_ES2015) */
 
 #endif /* ENABLED (JERRY_BUILTIN_ARRAY) */
 

jerry-core/ecma/builtin-objects/ecma-builtin-array.c

@@ -15,14 +15,16 @@
 
 #include "ecma-alloc.h"
 #include "ecma-builtins.h"
+#include "ecma-builtin-helpers.h"
 #include "ecma-conversion.h"
 #include "ecma-exceptions.h"
+#include "ecma-function-object.h"
 #include "ecma-gc.h"
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
+#include "ecma-iterator-object.h"
 #include "ecma-objects.h"
 #include "ecma-array-object.h"
-#include "ecma-try-catch-macro.h"
 #include "jrt.h"
 
 #if ENABLED (JERRY_BUILTIN_ARRAY)
@@ -58,20 +60,419 @@ ecma_builtin_array_object_is_array (ecma_value_t this_arg, /**< 'this' argument
                                     ecma_value_t arg) /**< first argument */
 {
   JERRY_UNUSED (this_arg);
-  ecma_value_t is_array = ECMA_VALUE_FALSE;
 
-  if (ecma_is_value_object (arg))
+  return ecma_make_boolean_value (ecma_is_value_array (arg));
+} /* ecma_builtin_array_object_is_array */
+
+#if ENABLED (JERRY_ES2015)
+/**
+ * The Array object's 'from' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 22.1.2.1
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_array_object_from (ecma_value_t this_arg, /**< 'this' argument */
+                                const ecma_value_t *arguments_list_p, /**< arguments list */
+                                ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  /* 1. */
+  ecma_value_t constructor = this_arg;
+  ecma_value_t call_this_arg = ECMA_VALUE_UNDEFINED;
+  ecma_value_t items = arguments_list_p[0];
+  ecma_value_t mapfn = (arguments_list_len > 1) ? arguments_list_p[1] : ECMA_VALUE_UNDEFINED;
+
+  /* 2. */
+  ecma_object_t *mapfn_obj_p = NULL;
+
+  /* 3. */
+  if (!ecma_is_value_undefined (mapfn))
   {
-    ecma_object_t *obj_p = ecma_get_object_from_value (arg);
-
-    if (ecma_object_get_class_name (obj_p) == LIT_MAGIC_STRING_ARRAY_UL)
+    /* 3.a */
+    if (!ecma_op_is_callable (mapfn))
     {
-      is_array = ECMA_VALUE_TRUE;
+      return ecma_raise_type_error (ECMA_ERR_MSG ("Callback function is not callable."));
     }
+
+    /* 3.b */
+    if (arguments_list_len > 2)
+    {
+      call_this_arg = arguments_list_p[2];
+    }
+
+    /* 3.c */
+    mapfn_obj_p = ecma_get_object_from_value (mapfn);
   }
 
-  return is_array;
-} /* ecma_builtin_array_object_is_array */
+  /* 4. */
+  ecma_value_t using_iterator = ecma_op_get_method_by_symbol_id (items, LIT_GLOBAL_SYMBOL_ITERATOR);
+
+  /* 5. */
+  if (ECMA_IS_VALUE_ERROR (using_iterator))
+  {
+    return using_iterator;
+  }
+
+  ecma_value_t ret_value = ECMA_VALUE_ERROR;
+
+  /* 6. */
+  if (!ecma_is_value_undefined (using_iterator))
+  {
+    ecma_value_t array;
+
+    /* 6.a */
+    if (ecma_is_constructor (constructor))
+    {
+      ecma_object_t *constructor_obj_p = ecma_get_object_from_value (constructor);
+
+      array = ecma_op_function_construct (constructor_obj_p, ECMA_VALUE_UNDEFINED, NULL, 0);
+
+      if (ecma_is_value_undefined (array) || ecma_is_value_null (array))
+      {
+        ecma_free_value (using_iterator);
+        return ecma_raise_type_error (ECMA_ERR_MSG ("Cannot convert undefined or null to object"));
+      }
+    }
+    else
+    {
+      /* 6.b */
+      array = ecma_op_create_array_object (NULL, 0, false);
+    }
+
+    /* 6.c */
+    if (ECMA_IS_VALUE_ERROR (array))
+    {
+      ecma_free_value (using_iterator);
+      return array;
+    }
+
+    ecma_object_t *array_obj_p = ecma_get_object_from_value (array);
+
+    /* 6.d */
+    ecma_value_t iterator = ecma_op_get_iterator (items, using_iterator);
+    ecma_free_value (using_iterator);
+
+    /* 6.e */
+    if (ECMA_IS_VALUE_ERROR (iterator))
+    {
+      ecma_free_value (array);
+      return iterator;
+    }
+
+    /* 6.f */
+    uint32_t k = 0;
+
+    /* 6.g */
+    while (true)
+    {
+      /* 6.g.ii */
+      ecma_value_t next = ecma_op_iterator_step (iterator);
+
+      /* 6.g.iii */
+      if (ECMA_IS_VALUE_ERROR (next))
+      {
+        goto iterator_cleanup;
+      }
+
+      /* 6.g.iii */
+      if (ecma_is_value_false (next))
+      {
+        /* 6.g.iv.1 */
+        ecma_value_t len_value = ecma_make_uint32_value (k);
+        ecma_value_t set_status = ecma_op_object_put (array_obj_p,
+                                                      ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH),
+                                                      len_value,
+                                                      true);
+        ecma_free_value (len_value);
+
+        /* 6.g.iv.2 */
+        if (ECMA_IS_VALUE_ERROR (set_status))
+        {
+          goto iterator_cleanup;
+        }
+
+        ecma_free_value (iterator);
+        /* 6.g.iv.3 */
+        return array;
+      }
+
+      /* 6.g.v */
+      ecma_value_t next_value = ecma_op_iterator_value (next);
+
+      ecma_free_value (next);
+
+      /* 6.g.vi */
+      if (ECMA_IS_VALUE_ERROR (next_value))
+      {
+        goto iterator_cleanup;
+      }
+
+      ecma_value_t mapped_value;
+      /* 6.g.vii */
+      if (mapfn_obj_p != NULL)
+      {
+        /* 6.g.vii.1 */
+        ecma_value_t args_p[2] = { next_value, ecma_make_uint32_value (k) };
+        /* 6.g.vii.3 */
+        mapped_value = ecma_op_function_call (mapfn_obj_p, call_this_arg, args_p, 2);
+        ecma_free_value (args_p[1]);
+        ecma_free_value (next_value);
+
+        /* 6.g.vii.2 */
+        if (ECMA_IS_VALUE_ERROR (mapped_value))
+        {
+          ecma_op_iterator_close (iterator);
+          goto iterator_cleanup;
+        }
+      }
+      else
+      {
+        /* 6.g.viii */
+        mapped_value = next_value;
+      }
+
+      /* 6.g.ix */
+      const uint32_t flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | ECMA_IS_THROW;
+      ecma_value_t set_status = ecma_builtin_helper_def_prop_by_index (array_obj_p, k, mapped_value, flags);
+
+      ecma_free_value (mapped_value);
+
+      /* 6.g.x */
+      if (ECMA_IS_VALUE_ERROR (set_status))
+      {
+        ecma_op_iterator_close (iterator);
+        goto iterator_cleanup;
+      }
+
+      /* 6.g.xi */
+      k++;
+    }
+
+iterator_cleanup:
+    ecma_free_value (iterator);
+    ecma_free_value (array);
+
+    return ret_value;
+  }
+
+  /* 8. */
+  ecma_value_t array_like = ecma_op_to_object (items);
+
+  /* 9. */
+  if (ECMA_IS_VALUE_ERROR (array_like))
+  {
+    return array_like;
+  }
+
+  ecma_object_t *array_like_obj_p = ecma_get_object_from_value (array_like);
+
+  /* 10. */
+  uint32_t len;
+  ecma_value_t len_value = ecma_op_object_get_length (array_like_obj_p, &len);
+
+  /* 11. */
+  if (ECMA_IS_VALUE_ERROR (len_value))
+  {
+    goto cleanup;
+  }
+
+  len_value = ecma_make_uint32_value (len);
+
+  /* 12. */
+  ecma_value_t array;
+
+  /* 12.a */
+  if (ecma_is_constructor (constructor))
+  {
+    ecma_object_t *constructor_obj_p = ecma_get_object_from_value (constructor);
+
+    array = ecma_op_function_construct (constructor_obj_p, ECMA_VALUE_UNDEFINED, &len_value, 1);
+
+    if (ecma_is_value_undefined (array) || ecma_is_value_null (array))
+    {
+      ecma_free_value (len_value);
+      ecma_raise_type_error (ECMA_ERR_MSG ("Cannot convert undefined or null to object"));
+      goto cleanup;
+    }
+  }
+  else
+  {
+    /* 13.a */
+    array = ecma_op_create_array_object (&len_value, 1, true);
+  }
+
+  ecma_free_value (len_value);
+
+  /* 14. */
+  if (ECMA_IS_VALUE_ERROR (array))
+  {
+    goto cleanup;
+  }
+
+  ecma_object_t *array_obj_p = ecma_get_object_from_value (array);
+
+  /* 15. */
+  uint32_t k = 0;
+
+  /* 16. */
+  while (k < len)
+  {
+    /* 16.b */
+    ecma_value_t k_value = ecma_op_object_get_by_uint32_index (array_like_obj_p, k);
+
+    /* 16.c */
+    if (ECMA_IS_VALUE_ERROR (k_value))
+    {
+      goto construct_cleanup;
+    }
+
+    ecma_value_t mapped_value;
+    /* 16.d */
+    if (mapfn_obj_p != NULL)
+    {
+      /* 16.d.i */
+      ecma_value_t args_p[2] = { k_value, ecma_make_uint32_value (k) };
+      mapped_value = ecma_op_function_call (mapfn_obj_p, call_this_arg, args_p, 2);
+      ecma_free_value (args_p[1]);
+      ecma_free_value (k_value);
+
+      /* 16.d.ii */
+      if (ECMA_IS_VALUE_ERROR (mapped_value))
+      {
+        goto construct_cleanup;
+      }
+    }
+    else
+    {
+      /* 16.e */
+      mapped_value = k_value;
+    }
+
+    /* 16.f */
+    const uint32_t flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | ECMA_IS_THROW;
+    ecma_value_t set_status = ecma_builtin_helper_def_prop_by_index (array_obj_p, k, mapped_value, flags);
+
+    ecma_free_value (mapped_value);
+
+    /* 16.g */
+    if (ECMA_IS_VALUE_ERROR (set_status))
+    {
+      goto construct_cleanup;
+    }
+
+    /* 16.h */
+    k++;
+  }
+
+  /* 17. */
+  len_value = ecma_make_uint32_value (k);
+  ecma_value_t set_status = ecma_op_object_put (array_obj_p,
+                                                ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH),
+                                                len_value,
+                                                true);
+  ecma_free_value (len_value);
+
+  /* 18. */
+  if (ECMA_IS_VALUE_ERROR (set_status))
+  {
+    goto construct_cleanup;
+  }
+
+  /* 19. */
+  ecma_deref_object (array_like_obj_p);
+  return ecma_make_object_value (array_obj_p);
+
+construct_cleanup:
+  ecma_deref_object (array_obj_p);
+cleanup:
+  ecma_deref_object (array_like_obj_p);
+  return ret_value;
+} /* ecma_builtin_array_object_from */
+
+/**
+ * The Array object's 'of' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 22.1.2.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_array_object_of (ecma_value_t this_arg, /**< 'this' argument */
+                              const ecma_value_t *arguments_list_p, /**< arguments list */
+                              ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  if (!ecma_is_constructor (this_arg))
+  {
+    return ecma_op_create_array_object (arguments_list_p, arguments_list_len, false);
+  }
+
+  ecma_value_t len = ecma_make_uint32_value (arguments_list_len);
+
+  ecma_value_t ret_val = ecma_op_function_construct (ecma_get_object_from_value (this_arg),
+                                                     ECMA_VALUE_UNDEFINED,
+                                                     &len,
+                                                     1);
+
+  if (ECMA_IS_VALUE_ERROR (ret_val))
+  {
+    ecma_free_value (len);
+    return ret_val;
+  }
+
+  uint32_t k = 0;
+  ecma_object_t *obj_p = ecma_get_object_from_value (ret_val);
+  const uint32_t prop_status_flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | ECMA_IS_THROW;
+
+  while (k < arguments_list_len)
+  {
+    ecma_value_t define_status = ecma_builtin_helper_def_prop_by_index (obj_p,
+                                                                        k,
+                                                                        arguments_list_p[k],
+                                                                        prop_status_flags);
+
+    if (ECMA_IS_VALUE_ERROR (define_status))
+    {
+      ecma_free_value (len);
+      ecma_deref_object (obj_p);
+      return define_status;
+    }
+
+    k++;
+  }
+
+  ret_val = ecma_op_object_put (obj_p,
+                                ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH),
+                                len,
+                                true);
+
+  ecma_free_value (len);
+
+  if (ECMA_IS_VALUE_ERROR (ret_val))
+  {
+    ecma_deref_object (obj_p);
+    return ret_val;
+  }
+
+  return ecma_make_object_value (obj_p);
+} /* ecma_builtin_array_object_of */
+
+/**
+ * 22.1.2.5 get Array [ @@species ] accessor
+ *
+ * @return ecma_value
+ *         returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_builtin_array_species_get (ecma_value_t this_value) /**< This Value */
+{
+  return ecma_copy_value (this_value);
+} /* ecma_builtin_array_species_get */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Handle calling [[Call]] of built-in Array object

jerry-core/ecma/builtin-objects/ecma-builtin-array.inc.h

@@ -40,6 +40,15 @@ NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH,
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
 ROUTINE (LIT_MAGIC_STRING_IS_ARRAY_UL, ecma_builtin_array_object_is_array, 1, 1)
+#if ENABLED (JERRY_ES2015)
+ROUTINE (LIT_MAGIC_STRING_FROM, ecma_builtin_array_object_from, NON_FIXED, 1)
+ROUTINE (LIT_MAGIC_STRING_OF, ecma_builtin_array_object_of, NON_FIXED, 0)
+
+/* ECMA-262 v6, 22.1.2.5 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES,
+                    ecma_builtin_array_species_get,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+#endif /* ENABLED (JERRY_ES2015) */
 
 #endif /* !(ENABLED (JERRY_BUILTIN_ARRAY)) */
 

jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer-prototype.c

@@ -61,6 +61,10 @@ ecma_builtin_arraybuffer_prototype_bytelength_getter (ecma_value_t this_arg) /**
 
     if (ecma_object_class_is (object_p, LIT_MAGIC_STRING_ARRAY_BUFFER_UL))
     {
+      if (ecma_arraybuffer_is_detached (object_p))
+      {
+        return ecma_raise_type_error (ECMA_ERR_MSG ("ArrayBuffer has been detached."));
+      }
       ecma_length_t len = ecma_arraybuffer_get_length (object_p);
 
       return ecma_make_uint32_value (len);
@@ -96,31 +100,34 @@ ecma_builtin_arraybuffer_prototype_object_slice (ecma_value_t this_arg, /**< thi
     return ecma_raise_type_error (ECMA_ERR_MSG ("Argument 'this' is not an ArrayBuffer object."));
   }
 
+  if (ecma_arraybuffer_is_detached (object_p))
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("ArrayBuffer has been detached."));
+  }
+
   ecma_length_t len = ecma_arraybuffer_get_length (object_p);
 
   ecma_length_t start = 0, end = len;
 
   ecma_value_t ret_value = ECMA_VALUE_EMPTY;
 
-  ECMA_OP_TO_NUMBER_TRY_CATCH (start_num,
-                               arg1,
-                               ret_value);
-
-  start = ecma_builtin_helper_array_index_normalize (start_num, len, false);
+  if (ECMA_IS_VALUE_ERROR (ecma_builtin_helper_array_index_normalize (arg1,
+                                                                      len,
+                                                                      &start)))
+  {
+    return ECMA_VALUE_ERROR;
+  }
 
   if (!ecma_is_value_undefined (arg2))
   {
-    ECMA_OP_TO_NUMBER_TRY_CATCH (end_num,
-                                 arg2,
-                                 ret_value);
-
-    end = ecma_builtin_helper_array_index_normalize (end_num, len, false);
-
-    ECMA_OP_TO_NUMBER_FINALIZE (end_num);
+    if (ECMA_IS_VALUE_ERROR (ecma_builtin_helper_array_index_normalize (arg2,
+                                                                        len,
+                                                                        &end)))
+    {
+      return ECMA_VALUE_ERROR;
+    }
   }
 
-  ECMA_OP_TO_NUMBER_FINALIZE (start_num);
-
   if (ret_value != ECMA_VALUE_EMPTY)
   {
     return ret_value;

jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer-prototype.inc.h

@@ -33,12 +33,12 @@ ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_BYTE_LENGTH_UL,
                     ecma_builtin_arraybuffer_prototype_bytelength_getter,
                     ECMA_PROPERTY_FIXED)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 24.1.4.4 */
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_ARRAY_BUFFER_UL,
               ECMA_PROPERTY_FLAG_CONFIGURABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */

jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer.c

@@ -19,7 +19,9 @@
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
 #include "ecma-arraybuffer-object.h"
+#include "ecma-dataview-object.h"
 #include "ecma-try-catch-macro.h"
+#include "ecma-typedarray-object.h"
 #include "jrt.h"
 
 #if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
@@ -55,11 +57,8 @@ ecma_builtin_arraybuffer_object_is_view (ecma_value_t this_arg, /**< 'this' argu
                                          ecma_value_t arg) /**< argument 1 */
 {
   JERRY_UNUSED (this_arg);
-  JERRY_UNUSED (arg);
 
-  /* TODO: if arg has [[ViewArrayBuffer]], return true */
-
-  return ECMA_VALUE_FALSE;
+  return ecma_make_boolean_value (ecma_is_typedarray (arg) || ecma_is_dataview (arg));
 } /* ecma_builtin_arraybuffer_object_is_view */
 
 /**
@@ -94,6 +93,18 @@ ecma_builtin_arraybuffer_dispatch_construct (const ecma_value_t *arguments_list_
   return ecma_op_create_arraybuffer_object (arguments_list_p, arguments_list_len);
 } /* ecma_builtin_arraybuffer_dispatch_construct */
 
+/**
+ * 24.1.3.3 get ArrayBuffer [ @@species ] accessor
+ *
+ * @return ecma_value
+ *         returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_builtin_arraybuffer_species_get (ecma_value_t this_value) /**< This Value */
+{
+  return ecma_copy_value (this_value);
+} /* ecma_builtin_arraybuffer_species_get */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer.inc.h

@@ -41,6 +41,11 @@ OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
 /* ES2015 24.1.3.1 */
 ROUTINE (LIT_MAGIC_STRING_IS_VIEW_UL, ecma_builtin_arraybuffer_object_is_view, 1, 1)
 
+/* ES2015 24.1.3.3 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES,
+                    ecma_builtin_arraybuffer_species_get,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-dataview-prototype.c

@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include "ecma-arraybuffer-object.h"
+#include "ecma-exceptions.h"
 #include "ecma-dataview-object.h"
 #include "ecma-gc.h"
 
@@ -110,11 +112,20 @@ ecma_builtin_dataview_prototype_object_getters (ecma_value_t this_arg, /**< this
     }
     case ECMA_DATAVIEW_PROTOTYPE_BYTE_LENGTH_GETTER:
     {
+      if (ecma_arraybuffer_is_detached (obj_p->buffer_p))
+      {
+        return ecma_raise_type_error (ECMA_ERR_MSG ("ArrayBuffer has been detached."));
+      }
       return ecma_make_uint32_value (obj_p->header.u.class_prop.u.length);
     }
     default:
     {
       JERRY_ASSERT (builtin_routine_id == ECMA_DATAVIEW_PROTOTYPE_BYTE_OFFSET_GETTER);
+
+      if (ecma_arraybuffer_is_detached (obj_p->buffer_p))
+      {
+        return ecma_raise_type_error (ECMA_ERR_MSG ("ArrayBuffer has been detached."));
+      }
       return ecma_make_uint32_value (obj_p->byte_offset);
     }
   }

jerry-core/ecma/builtin-objects/ecma-builtin-dataview-prototype.inc.h

@@ -29,12 +29,12 @@ OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR,
               ECMA_BUILTIN_ID_DATAVIEW,
               ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 23.2.4.21 */
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_DATAVIEW_UL,
               ECMA_PROPERTY_FLAG_CONFIGURABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */

jerry-core/ecma/builtin-objects/ecma-builtin-date-prototype.c

@@ -22,6 +22,7 @@
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
 #include "ecma-objects.h"
+#include "ecma-objects-general.h"
 #include "ecma-try-catch-macro.h"
 
 #if ENABLED (JERRY_BUILTIN_DATE)
@@ -98,6 +99,10 @@ enum
   ECMA_DATE_PROTOTYPE_GET_TIME, /* ECMA-262 v5, 15.9.5.9 */
   ECMA_DATE_PROTOTYPE_SET_TIME, /* ECMA-262 v5, 15.9.5.27 */
   ECMA_DATE_PROTOTYPE_TO_JSON, /* ECMA-262 v5, 15.9.5.44 */
+
+#if ENABLED (JERRY_ES2015)
+  ECMA_DATE_PROTOTYPE_TO_PRIMITIVE, /*  ECMA-262 v6 20.3.4.45 */
+#endif /* ENABLED (JERRY_ES2015) */
 };
 
 #define BUILTIN_INC_HEADER_NAME "ecma-builtin-date-prototype.inc.h"
@@ -179,6 +184,46 @@ ecma_builtin_date_prototype_to_json (ecma_value_t this_arg) /**< this argument *
   return ret_value;
 } /* ecma_builtin_date_prototype_to_json */
 
+#if ENABLED (JERRY_ES2015)
+/**
+ * The Date.prototype object's toPrimitive routine
+ *
+ * See also:
+ *          ECMA-262 v6, 20.3.4.45
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_date_prototype_to_primitive (ecma_value_t this_arg, /**< this argument */
+                                          ecma_value_t hint_arg) /**< {"default", "number", "string"} */
+{
+  if (ecma_is_value_object (this_arg) && ecma_is_value_string (hint_arg))
+  {
+    ecma_string_t *hint_str_p = ecma_get_string_from_value (hint_arg);
+
+    ecma_preferred_type_hint_t hint = ECMA_PREFERRED_TYPE_NUMBER;
+
+    if (hint_str_p == ecma_get_magic_string (LIT_MAGIC_STRING_STRING)
+        || hint_str_p == ecma_get_magic_string (LIT_MAGIC_STRING_DEFAULT))
+    {
+      hint = ECMA_PREFERRED_TYPE_STRING;
+    }
+    else if (hint_str_p == ecma_get_magic_string (LIT_MAGIC_STRING_NUMBER))
+    {
+      hint = ECMA_PREFERRED_TYPE_NUMBER;
+    }
+
+    if (hint != ECMA_PREFERRED_TYPE_NO)
+    {
+      return ecma_op_general_object_ordinary_value (ecma_get_object_from_value (this_arg), hint);
+    }
+  }
+
+  return ecma_raise_type_error (ECMA_ERR_MSG ("Invalid argument type in toPrimitive."));
+} /* ecma_builtin_date_prototype_to_primitive */
+#endif /* ENABLED (JERRY_ES2015) */
+
 /**
  * Dispatch get date functions
  *
@@ -560,6 +605,14 @@ ecma_builtin_date_prototype_dispatch_routine (uint16_t builtin_routine_id, /**<
     return ecma_builtin_date_prototype_to_json (this_arg);
   }
 
+#if ENABLED (JERRY_ES2015)
+  if (JERRY_UNLIKELY (builtin_routine_id == ECMA_DATE_PROTOTYPE_TO_PRIMITIVE))
+  {
+    ecma_value_t argument = arguments_number > 0 ? arguments_list[0] : ECMA_VALUE_UNDEFINED;
+    return ecma_builtin_date_prototype_to_primitive (this_arg, argument);
+  }
+#endif /* ENABLED (JERRY_ES2015) */
+
   if (!ecma_is_value_object (this_arg)
       || !ecma_object_class_is (ecma_get_object_from_value (this_arg), LIT_MAGIC_STRING_DATE_UL))
   {

jerry-core/ecma/builtin-objects/ecma-builtin-date-prototype.inc.h

@@ -68,6 +68,9 @@ ROUTINE (LIT_MAGIC_STRING_SET_UTC_FULL_YEAR_UL, ECMA_DATE_PROTOTYPE_SET_UTC_FULL
 ROUTINE (LIT_MAGIC_STRING_TO_UTC_STRING_UL, ECMA_DATE_PROTOTYPE_TO_UTC_STRING, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_TO_ISO_STRING_UL, ECMA_DATE_PROTOTYPE_TO_ISO_STRING, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_TO_JSON_UL, ECMA_DATE_PROTOTYPE_TO_JSON, 1, 1)
+#if ENABLED (JERRY_ES2015)
+ROUTINE_CONFIGURABLE_ONLY (LIT_GLOBAL_SYMBOL_TO_PRIMITIVE, ECMA_DATE_PROTOTYPE_TO_PRIMITIVE, 1, 1)
+#endif /* ENABLED (JERRY_ES2015) */
 
 #if ENABLED (JERRY_BUILTIN_ANNEXB)
 

jerry-core/ecma/builtin-objects/ecma-builtin-date.c

@@ -52,22 +52,137 @@
 static ecma_number_t
 ecma_date_parse_date_chars (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
                             const lit_utf8_byte_t *str_end_p, /**< pointer to the end of the string */
-                            uint32_t num_of_chars) /**< number of characters to read and convert */
+                            uint32_t num_of_chars, /**< number of characters to read and convert */
+                            uint32_t min, /**< minimum valid value */
+                            uint32_t max) /**< maximum valid value */
 {
   JERRY_ASSERT (num_of_chars > 0);
   const lit_utf8_byte_t *str_start_p = *str_p;
 
   while (num_of_chars--)
   {
-    if (*str_p >= str_end_p || !lit_char_is_decimal_digit (lit_utf8_read_next (str_p)))
+    if (*str_p >= str_end_p || !lit_char_is_decimal_digit (lit_cesu8_read_next (str_p)))
     {
       return ecma_number_make_nan ();
     }
   }
 
-  return ecma_utf8_string_to_number (str_start_p, (lit_utf8_size_t) (*str_p - str_start_p));
+  ecma_number_t parsed_number = ecma_utf8_string_to_number (str_start_p, (lit_utf8_size_t) (*str_p - str_start_p));
+
+  if (parsed_number < min || parsed_number > max)
+  {
+    return ecma_number_make_nan ();
+  }
+
+  return parsed_number;
 } /* ecma_date_parse_date_chars */
 
+/**
+ * Helper function to try to parse a special chracter (+,-,T,Z,:,.) in a date string
+ *
+ * @return true if the first character is same as the expected, false otherwise
+ */
+static bool
+ecma_date_parse_special_char (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                              const lit_utf8_byte_t *str_end_p, /**< pointer to the end of the string */
+                              const lit_utf8_byte_t expected_char) /**< expected character */
+{
+  if ((*str_p < str_end_p) && (**str_p == expected_char))
+  {
+    (*str_p)++;
+    return true;
+  }
+
+  return false;
+} /* ecma_date_parse_special_char */
+
+/**
+ * Helper function to try to parse a 4-5-6 digit year with optional negative sign in a date string
+ *
+ * Date.prototype.toString() and Date.prototype.toUTCString() emits year
+ * in this format and Date.parse() should parse this format too.
+ *
+ * @return the parsed year or NaN.
+ */
+static ecma_number_t
+ecma_date_parse_year (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                      const lit_utf8_byte_t *str_end_p) /**< pointer to the end of the string */
+{
+  bool is_year_sign_negative = ecma_date_parse_special_char (str_p, str_end_p, '-');
+  const lit_utf8_byte_t *str_start_p = *str_p;
+  int32_t parsed_year = 0;
+
+  while ((str_start_p - *str_p < 6) && (str_start_p < str_end_p) && lit_char_is_decimal_digit (*str_start_p))
+  {
+    parsed_year = 10 * parsed_year + *str_start_p - LIT_CHAR_0;
+    str_start_p++;
+  }
+
+  if (str_start_p - *str_p >=4)
+  {
+    *str_p = str_start_p;
+    if (is_year_sign_negative)
+    {
+      return -parsed_year;
+    }
+    return parsed_year;
+  }
+
+  return ecma_number_make_nan ();
+} /* ecma_date_parse_year */
+
+/**
+ * Helper function to try to parse a day name in a date string
+ * Valid day names: Sun, Mon, Tue, Wed, Thu, Fri, Sat
+ * See also:
+ *          ECMA-262 v9, 20.3.4.41.2 Table 46
+ *
+ * @return true if the string starts with a valid day name, false otherwise
+ */
+static bool
+ecma_date_parse_day_name (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                          const lit_utf8_byte_t *str_end_p) /**< pointer to the end of the string */
+{
+  if (*str_p + 3 < str_end_p)
+  {
+    for (uint32_t i = 0; i < 7; i++)
+    {
+      if (!memcmp (day_names_p[i], *str_p, 3))
+      {
+        (*str_p) += 3;
+        return true;
+      }
+    }
+  }
+  return false;
+} /* ecma_date_parse_day_name */
+
+/**
+ * Helper function to try to parse a month name in a date string
+ * Valid month names: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec
+ * See also:
+ *          ECMA-262 v9, 20.3.4.41.2 Table 47
+ *
+ * @return number of the month if the string starts with a valid month name, 0 otherwise
+ */
+static uint32_t
+ecma_date_parse_month_name (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                            const lit_utf8_byte_t *str_end_p) /**< pointer to the end of the string */
+{
+  if (*str_p + 3 < str_end_p)
+  {
+    for (uint32_t i = 0; i < 12; i++)
+    {
+      if (!memcmp (month_names_p[i], *str_p, 3))
+      {
+        (*str_p) += 3;
+        return (i+1);
+      }
+    }
+  }
+  return 0;
+} /* ecma_date_parse_month_name */
+
 /**
   * Calculate MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli)) for Date constructor and UTC
   *
@@ -169,52 +284,31 @@ ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to t
 } /* ecma_date_construct_helper */
 
 /**
- * The Date object's 'parse' routine
+ * Helper function used by ecma_builtin_date_parse
  *
  * See also:
- *          ECMA-262 v5, 15.9.4.2
- *          ECMA-262 v5, 15.9.1.15
+ *          ECMA-262 v5, 15.9.4.2  Date.parse (string)
+ *          ECMA-262 v5, 15.9.1.15 Date Time String Format
  *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value.
+ * @return the parsed date as ecma_number_t or NaN otherwise
  */
-static ecma_value_t
-ecma_builtin_date_parse (ecma_value_t this_arg, /**< this argument */
-                         ecma_value_t arg) /**< string */
+static ecma_number_t
+ecma_builtin_date_parse_ISO_string_format (const lit_utf8_byte_t *date_str_curr_p,
+                                           const lit_utf8_byte_t *date_str_end_p)
 {
-  JERRY_UNUSED (this_arg);
-  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
-  ecma_number_t date_num = ecma_number_make_nan ();
-
-  /* Date Time String fromat (ECMA-262 v5, 15.9.1.15) */
-  ECMA_TRY_CATCH (date_str_value,
-                  ecma_op_to_string (arg),
-                  ret_value);
-
-  ecma_string_t *date_str_p = ecma_get_string_from_value (date_str_value);
-
-  ECMA_STRING_TO_UTF8_STRING (date_str_p, date_start_p, date_start_size);
-
-  const lit_utf8_byte_t *date_str_curr_p = date_start_p;
-  const lit_utf8_byte_t *date_str_end_p = date_start_p + date_start_size;
-
   /* 1. read year */
 
   uint32_t year_digits = 4;
-  bool year_sign = false; /* false: positive, true: negative */
-  if (*date_str_curr_p == '-' || *date_str_curr_p == '+')
+
+  bool is_year_sign_negative = ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '-');
+  if (is_year_sign_negative || ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '+'))
   {
     year_digits = 6;
-    if (*date_str_curr_p == '-')
-    {
-      year_sign = true;
-    }
-    /* eat up '-' or '+' */
-    date_str_curr_p++;
   }
 
-  ecma_number_t year = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, year_digits);
-  if (year_sign)
+  ecma_number_t year = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, year_digits,
+                                                   0, (year_digits == 4) ? 9999 : 999999);
+  if (is_year_sign_negative)
   {
     year = -year;
   }
@@ -226,40 +320,20 @@ ecma_builtin_date_parse (ecma_value_t this_arg, /**< this argument */
     ecma_number_t time = ECMA_NUMBER_ZERO;
 
     /* 2. read month if any */
-    if (date_str_curr_p < date_str_end_p
-        && *date_str_curr_p == '-')
+    if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '-'))
     {
-      /* eat up '-' */
-      date_str_curr_p++;
-      month = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2);
-
-      if (month > 12 || month < 1)
-      {
-        month = ecma_number_make_nan ();
-      }
+      month = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 1, 12);
     }
 
     /* 3. read day if any */
-    if (date_str_curr_p < date_str_end_p
-        && *date_str_curr_p == '-')
+    if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '-'))
     {
-      /* eat up '-' */
-      date_str_curr_p++;
-      day = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2);
-
-      if (day < 1 || day > 31)
-      {
-        day = ecma_number_make_nan ();
-      }
+      day = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 1, 31);
     }
 
     /* 4. read time if any */
-    if (date_str_curr_p < date_str_end_p
-        && *date_str_curr_p == 'T')
+    if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, 'T'))
     {
-      /* eat up 'T' */
-      date_str_curr_p++;
-
       ecma_number_t hours = ECMA_NUMBER_ZERO;
       ecma_number_t minutes = ECMA_NUMBER_ZERO;
       ecma_number_t seconds = ECMA_NUMBER_ZERO;
@@ -271,54 +345,28 @@ ecma_builtin_date_parse (ecma_value_t this_arg, /**< this argument */
       if (remaining_length >= 5)
       {
         /* 4.1 read hours and minutes */
-        hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2);
+        hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 24);
 
-        if (hours < 0 || hours > 24)
+        if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ':'))
         {
-          hours = ecma_number_make_nan ();
-        }
-
-        if (date_str_curr_p < date_str_end_p
-            && *date_str_curr_p == ':')
-        {
-          /* eat up ':' */
-          date_str_curr_p++;
-
-          minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2);
-
-          if (minutes < 0 || minutes > 59)
-          {
-            minutes = ecma_number_make_nan ();
-          }
+          minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 59);
 
           /* 4.2 read seconds if any */
-          if (date_str_curr_p < date_str_end_p
-              && *date_str_curr_p == ':')
+          if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ':'))
           {
-            /* eat up ':' */
-            date_str_curr_p++;
-            seconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2);
-
-            if (seconds < 0 || seconds > 59)
-            {
-              seconds = ecma_number_make_nan ();
-            }
+            seconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 59);
 
             /* 4.3 read milliseconds if any */
-            if (date_str_curr_p < date_str_end_p
-                && *date_str_curr_p == '.')
+            if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '.'))
             {
-              /* eat up '.' */
-              date_str_curr_p++;
-              milliseconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 3);
-
-              if (milliseconds < 0)
-              {
-                milliseconds = ecma_number_make_nan ();
-              }
+              milliseconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 3, 0, 999);
             }
           }
         }
+        else
+        {
+          minutes = ecma_number_make_nan ();
+        }
 
         if (hours == 24 && (minutes != 0 || seconds != 0 || milliseconds != 0))
         {
@@ -333,62 +381,29 @@ ecma_builtin_date_parse (ecma_value_t this_arg, /**< this argument */
       }
 
       /* 4.4 read timezone if any */
-      if (date_str_curr_p < date_str_end_p
-          && *date_str_curr_p == 'Z'
-          && !ecma_number_is_nan (time))
+      if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, 'Z') && !ecma_number_is_nan (time))
       {
-        date_str_curr_p++;
         time = ecma_date_make_time (hours, minutes, seconds, milliseconds);
       }
-      else if (date_str_curr_p < date_str_end_p
-               && (*date_str_curr_p == '+' || *date_str_curr_p == '-'))
+      else
       {
-        ecma_length_t remaining_date_length;
-        remaining_date_length = lit_utf8_string_length (date_str_curr_p,
-                                                        (lit_utf8_size_t) (date_str_end_p - date_str_curr_p)) - 1;
-
-        if (remaining_date_length == 5)
+        bool is_timezone_sign_negative;
+        if ((lit_utf8_string_length (date_str_curr_p, (lit_utf8_size_t) (date_str_end_p - date_str_curr_p)) == 6)
+            && ((is_timezone_sign_negative = ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '-'))
+            || ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '+')))
         {
-          bool is_negative = false;
-
-          if (*date_str_curr_p == '-')
-          {
-            is_negative = true;
-          }
-
-          /* eat up '+/-' */
-          date_str_curr_p++;
-
           /* read hours and minutes */
-          hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2);
+          hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 24);
 
-          if (hours < 0 || hours > 24)
-          {
-            hours = ecma_number_make_nan ();
-          }
-          else if (hours == 24)
+          if (hours == 24)
           {
             hours = ECMA_NUMBER_ZERO;
           }
 
-          /* eat up ':' */
-          date_str_curr_p++;
-
-          minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2);
-
-          if (minutes < 0 || minutes > 59)
-          {
-            minutes = ecma_number_make_nan ();
-          }
-
-          if (is_negative)
-          {
-            time += ecma_date_make_time (hours, minutes, ECMA_NUMBER_ZERO, ECMA_NUMBER_ZERO);
-          }
-          else
-          {
-            time -= ecma_date_make_time (hours, minutes, ECMA_NUMBER_ZERO, ECMA_NUMBER_ZERO);
-          }
+          ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ':');
+          minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 59);
+          ecma_number_t timezone_offset = ecma_date_make_time (hours, minutes, ECMA_NUMBER_ZERO, ECMA_NUMBER_ZERO);
+          time += is_timezone_sign_negative ? timezone_offset : -timezone_offset;
         }
       }
     }
@@ -396,16 +411,232 @@ ecma_builtin_date_parse (ecma_value_t this_arg, /**< this argument */
     if (date_str_curr_p >= date_str_end_p)
     {
       ecma_number_t date = ecma_date_make_day (year, month - 1, day);
-      date_num = ecma_date_make_date (date, time);
+      return ecma_date_make_date (date, time);
+    }
+  }
+  return ecma_number_make_nan ();
+} /* ecma_builtin_date_parse_ISO_string_format */
+
+/**
+ * Helper function used by ecma_builtin_date_parse
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.4.2  Date.parse (string)
+ *          ECMA-262 v9, 20.3.4.41 Date.prototype.toString ()
+ *          ECMA-262 v9, 20.3.4.43 Date.prototype.toUTCString ()
+ *
+ * Used by: ecma_builtin_date_parse
+ *
+ * @return the parsed date as ecma_number_t or NaN otherwise
+ */
+static ecma_number_t
+ecma_builtin_date_parse_toString_formats (const lit_utf8_byte_t *date_str_curr_p,
+                                          const lit_utf8_byte_t *date_str_end_p)
+{
+  const ecma_number_t nan = ecma_number_make_nan ();
+
+  if (!ecma_date_parse_day_name (&date_str_curr_p, date_str_end_p))
+  {
+    return nan;
+  }
+
+  const bool is_toUTCString_format = ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ',');
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ' '))
+  {
+    return nan;
+  }
+
+  ecma_number_t month = 0;
+  ecma_number_t day = 0;
+  if (is_toUTCString_format)
+  {
+    day = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 31);
+    if (ecma_number_is_nan (day))
+    {
+      return nan;
+    }
+
+    if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ' '))
+    {
+      return nan;
+    }
+
+    month = ecma_date_parse_month_name (&date_str_curr_p, date_str_end_p);
+    if (!(int) month)
+    {
+      return nan;
+    }
+  }
+  else
+  {
+    month = ecma_date_parse_month_name (&date_str_curr_p, date_str_end_p);
+    if (!(int) month)
+    {
+      return nan;
+    }
+
+    if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ' '))
+    {
+      return nan;
+    }
+
+    day = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 31);
+    if (ecma_number_is_nan (day))
+    {
+      return nan;
     }
   }
 
-  ret_value = ecma_make_number_value (date_num);
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ' '))
+  {
+    return nan;
+  }
+
+  ecma_number_t year = ecma_date_parse_year (&date_str_curr_p, date_str_end_p);
+  if (ecma_number_is_nan (year))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ' '))
+  {
+    return nan;
+  }
+
+  ecma_number_t hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 24);
+  if (ecma_number_is_nan (hours))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ':'))
+  {
+    return nan;
+  }
+
+  ecma_number_t minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 59);
+  if (ecma_number_is_nan (minutes))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ':'))
+  {
+    return nan;
+  }
+
+  ecma_number_t seconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 59);
+  if (ecma_number_is_nan (seconds))
+  {
+    return nan;
+  }
+
+  if (hours == 24 && (minutes != 0 || seconds != 0))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, ' '))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, 'G'))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, 'M'))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, 'T'))
+  {
+    return nan;
+  }
+
+  ecma_number_t time = ecma_date_make_time (hours, minutes, seconds, 0);
+
+  if (!is_toUTCString_format)
+  {
+    bool is_timezone_sign_negative = ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '-');
+    if (!is_timezone_sign_negative && !ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, '+'))
+    {
+      return nan;
+    }
+
+    hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 24);
+    if (ecma_number_is_nan (hours))
+    {
+      return nan;
+    }
+    if (hours == 24)
+    {
+      hours = ECMA_NUMBER_ZERO;
+    }
+
+    minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, 0, 59);
+    if (ecma_number_is_nan (minutes))
+    {
+      return nan;
+    }
+
+    ecma_number_t timezone_offset = ecma_date_make_time (hours, minutes, ECMA_NUMBER_ZERO, ECMA_NUMBER_ZERO);
+    time += is_timezone_sign_negative ? timezone_offset : -timezone_offset;
+  }
+
+  if (date_str_curr_p >= date_str_end_p)
+  {
+    ecma_number_t date = ecma_date_make_day (year, month - 1, day);
+    return ecma_date_make_date (date, time);
+  }
+
+  return nan;
+} /* ecma_builtin_date_parse_toString_formats */
+
+/**
+ * The Date object's 'parse' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.4.2  Date.parse (string)
+ *          ECMA-262 v5, 15.9.1.15 Date Time String Format
+ *          ECMA-262 v9, 20.3.4.41 Date.prototype.toString ()
+ *          ECMA-262 v9, 20.3.4.43 Date.prototype.toUTCString ()
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_date_parse (ecma_value_t this_arg, /**< this argument */
+                         ecma_value_t arg) /**< string */
+{
+  JERRY_UNUSED (this_arg);
+
+  /* Date Time String fromat (ECMA-262 v5, 15.9.1.15) */
+  ecma_string_t *date_str_p = ecma_op_to_string (arg);
+  if (JERRY_UNLIKELY (date_str_p == NULL))
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  ECMA_STRING_TO_UTF8_STRING (date_str_p, date_start_p, date_start_size);
+  const lit_utf8_byte_t *date_str_curr_p = date_start_p;
+  const lit_utf8_byte_t *date_str_end_p = date_start_p + date_start_size;
+
+  // try to parse date string as ISO string - ECMA-262 v5, 15.9.1.15
+  ecma_number_t ret_value = ecma_builtin_date_parse_ISO_string_format (date_str_curr_p, date_str_end_p);
+
+  if (ecma_number_is_nan (ret_value))
+  {
+    // try to parse date string in Date.prototype.toString() or toUTCString() format
+    ret_value = ecma_builtin_date_parse_toString_formats (date_str_curr_p, date_str_end_p);
+  }
 
   ECMA_FINALIZE_UTF8_STRING (date_start_p, date_start_size);
-  ECMA_FINALIZE (date_str_value);
-
-  return ret_value;
+  ecma_deref_ecma_string (date_str_p);
+  return ecma_make_number_value (ret_value);
 } /* ecma_builtin_date_parse */
 
 /**
@@ -589,4 +820,7 @@ ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
  * @}
  */
 
+#undef BREAK_IF_FALSE
+#undef BREAK_IF_NAN
+
 #endif /* ENABLED (JERRY_BUILTIN_DATE) */

jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.c

@@ -20,6 +20,7 @@
 #include "ecma-gc.h"
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
+#include "lit-char-helpers.h"
 #include "ecma-objects.h"
 #include "ecma-string-object.h"
 #include "ecma-try-catch-macro.h"
@@ -43,6 +44,34 @@
  * @{
  */
 
+/**
+ * Helper method to get a property value from an error object
+ *
+ * @return ecma_string_t
+ */
+static ecma_string_t *
+ecma_builtin_error_prototype_object_to_string_helper (ecma_object_t *obj_p, /**< error object */
+                                                      lit_magic_string_id_t property_id, /**< property id */
+                                                      lit_magic_string_id_t default_value) /**< default prop value */
+{
+  ecma_value_t prop_value = ecma_op_object_get_by_magic_id (obj_p, property_id);
+
+  if (ECMA_IS_VALUE_ERROR (prop_value))
+  {
+    return NULL;
+  }
+
+  if (ecma_is_value_undefined (prop_value))
+  {
+    return ecma_get_magic_string (default_value);
+  }
+
+  ecma_string_t *ret_str_p = ecma_op_to_string (prop_value);
+  ecma_free_value (prop_value);
+
+  return ret_str_p;
+} /* ecma_builtin_error_prototype_object_to_string_helper */
+
 /**
  * The Error.prototype object's 'toString' routine
  *
@@ -55,125 +84,52 @@
 static ecma_value_t
 ecma_builtin_error_prototype_object_to_string (ecma_value_t this_arg) /**< this argument */
 {
-  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
-
   /* 2. */
   if (!ecma_is_value_object (this_arg))
   {
-    ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("Argument 'this' is not an object."));
+    return ecma_raise_type_error (ECMA_ERR_MSG ("Argument 'this' is not an object."));
   }
-  else
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
+
+  ecma_string_t *name_string_p = ecma_builtin_error_prototype_object_to_string_helper (obj_p,
+                                                                                       LIT_MAGIC_STRING_NAME,
+                                                                                       LIT_MAGIC_STRING_ERROR_UL);
+
+  if (JERRY_UNLIKELY (name_string_p == NULL))
   {
-    ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
-
-    ECMA_TRY_CATCH (name_get_ret_value,
-                    ecma_op_object_get_by_magic_id (obj_p, LIT_MAGIC_STRING_NAME),
-                    ret_value);
-
-    ecma_value_t name_to_str_completion;
-
-    if (ecma_is_value_undefined (name_get_ret_value))
-    {
-      name_to_str_completion = ecma_make_magic_string_value (LIT_MAGIC_STRING_ERROR_UL);
-    }
-    else
-    {
-      name_to_str_completion = ecma_op_to_string (name_get_ret_value);
-    }
-
-    if (JERRY_UNLIKELY (ECMA_IS_VALUE_ERROR (name_to_str_completion)))
-    {
-      ret_value = ecma_copy_value (name_to_str_completion);
-    }
-    else
-    {
-      ECMA_TRY_CATCH (msg_get_ret_value,
-                      ecma_op_object_get_by_magic_id (obj_p, LIT_MAGIC_STRING_MESSAGE),
-                      ret_value);
-
-      ecma_value_t msg_to_str_completion;
-
-      if (ecma_is_value_undefined (msg_get_ret_value))
-      {
-        msg_to_str_completion = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
-      }
-      else
-      {
-        msg_to_str_completion = ecma_op_to_string (msg_get_ret_value);
-      }
-
-      if (JERRY_UNLIKELY (ECMA_IS_VALUE_ERROR (msg_to_str_completion)))
-      {
-        ret_value = ecma_copy_value (msg_to_str_completion);
-      }
-      else
-      {
-        ecma_string_t *name_string_p = ecma_get_string_from_value (name_to_str_completion);
-        ecma_string_t *msg_string_p = ecma_get_string_from_value (msg_to_str_completion);
-
-        ecma_string_t *ret_str_p;
-
-        if (ecma_string_is_empty (name_string_p))
-        {
-          ret_str_p = msg_string_p;
-          ecma_ref_ecma_string (ret_str_p);
-        }
-        else if (ecma_string_is_empty (msg_string_p))
-        {
-          ret_str_p = name_string_p;
-          ecma_ref_ecma_string (ret_str_p);
-        }
-        else
-        {
-          const lit_utf8_size_t name_size = ecma_string_get_size (name_string_p);
-          const lit_utf8_size_t msg_size = ecma_string_get_size (msg_string_p);
-          const lit_utf8_size_t colon_size = lit_get_magic_string_size (LIT_MAGIC_STRING_COLON_CHAR);
-          const lit_utf8_size_t space_size = lit_get_magic_string_size (LIT_MAGIC_STRING_SPACE_CHAR);
-          const lit_utf8_size_t size = name_size + msg_size + colon_size + space_size;
-
-          JMEM_DEFINE_LOCAL_ARRAY (ret_str_buffer, size, lit_utf8_byte_t);
-          lit_utf8_byte_t *ret_str_buffer_p = ret_str_buffer;
-
-          lit_utf8_size_t bytes = ecma_string_copy_to_cesu8_buffer (name_string_p, ret_str_buffer_p, name_size);
-          JERRY_ASSERT (bytes == name_size);
-          ret_str_buffer_p = ret_str_buffer_p + bytes;
-          JERRY_ASSERT (ret_str_buffer_p <= ret_str_buffer + size);
-
-          ret_str_buffer_p = lit_copy_magic_string_to_buffer (LIT_MAGIC_STRING_COLON_CHAR,
-                                                              ret_str_buffer_p,
-                                                              colon_size);
-          JERRY_ASSERT (ret_str_buffer_p <= ret_str_buffer + size);
-
-          ret_str_buffer_p = lit_copy_magic_string_to_buffer (LIT_MAGIC_STRING_SPACE_CHAR,
-                                                              ret_str_buffer_p,
-                                                              space_size);
-          JERRY_ASSERT (ret_str_buffer_p <= ret_str_buffer + size);
-
-          bytes = ecma_string_copy_to_cesu8_buffer (msg_string_p, ret_str_buffer_p, msg_size);
-          JERRY_ASSERT (bytes == msg_size);
-          ret_str_buffer_p = ret_str_buffer_p + bytes;
-          JERRY_ASSERT (ret_str_buffer_p == ret_str_buffer + size);
-
-          ret_str_p = ecma_new_ecma_string_from_utf8 (ret_str_buffer,
-                                                      size);
-
-          JMEM_FINALIZE_LOCAL_ARRAY (ret_str_buffer);
-        }
-
-        ret_value = ecma_make_string_value (ret_str_p);
-      }
-
-      ecma_free_value (msg_to_str_completion);
-
-      ECMA_FINALIZE (msg_get_ret_value);
-    }
-
-    ecma_free_value (name_to_str_completion);
-
-    ECMA_FINALIZE (name_get_ret_value);
+    return ECMA_VALUE_ERROR;
   }
 
-  return ret_value;
+  ecma_string_t *msg_string_p = ecma_builtin_error_prototype_object_to_string_helper (obj_p,
+                                                                                      LIT_MAGIC_STRING_MESSAGE,
+                                                                                      LIT_MAGIC_STRING__EMPTY);
+
+  if (JERRY_UNLIKELY (msg_string_p == NULL))
+  {
+    ecma_deref_ecma_string (name_string_p);
+    return ECMA_VALUE_ERROR;
+  }
+
+  if (ecma_string_is_empty (name_string_p))
+  {
+    return ecma_make_string_value (msg_string_p);
+  }
+
+  if (ecma_string_is_empty (msg_string_p))
+  {
+    return ecma_make_string_value (name_string_p);
+  }
+
+  ecma_stringbuilder_t builder = ecma_stringbuilder_create_from (name_string_p);
+
+  ecma_stringbuilder_append_raw (&builder, (const lit_utf8_byte_t *)": ", 2);
+  ecma_stringbuilder_append (&builder, msg_string_p);
+
+  ecma_deref_ecma_string (name_string_p);
+  ecma_deref_ecma_string (msg_string_p);
+
+  return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
 } /* ecma_builtin_error_prototype_object_to_string */
 
 /**

jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.c

@@ -25,6 +25,7 @@
 #include "ecma-objects.h"
 #include "ecma-try-catch-macro.h"
 #include "jrt.h"
+#include "ecma-builtin-function-prototype.h"
 
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"
@@ -44,6 +45,9 @@ enum
   ECMA_FUNCTION_PROTOTYPE_CALL,
   ECMA_FUNCTION_PROTOTYPE_APPLY,
   ECMA_FUNCTION_PROTOTYPE_BIND,
+#if ENABLED (JERRY_ES2015)
+  ECMA_FUNCTION_PROTOTYPE_SYMBOL_HAS_INSTANCE,
+#endif /* ENABLED (JERRY_ES2015) */
 };
 
 #define BUILTIN_INC_HEADER_NAME "ecma-builtin-function-prototype.inc.h"
@@ -89,7 +93,7 @@ ecma_builtin_function_prototype_object_to_string (void)
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-static ecma_value_t
+ecma_value_t
 ecma_builtin_function_prototype_object_apply (ecma_object_t *func_obj_p, /**< this argument object */
                                               ecma_value_t arg1, /**< first argument */
                                               ecma_value_t arg2) /**< second argument */
@@ -108,27 +112,15 @@ ecma_builtin_function_prototype_object_apply (ecma_object_t *func_obj_p, /**< th
 
   ecma_object_t *obj_p = ecma_get_object_from_value (arg2);
 
-  /* 4. */
-  ecma_value_t length_value = ecma_op_object_get_by_magic_id (obj_p, LIT_MAGIC_STRING_LENGTH);
-  if (ECMA_IS_VALUE_ERROR (length_value))
+  /* 4-5. */
+  uint32_t length;
+  ecma_value_t len_value = ecma_op_object_get_length (obj_p, &length);
+
+  if (ECMA_IS_VALUE_ERROR (len_value))
   {
-    return length_value;
+    return len_value;
   }
 
-  ecma_number_t length_number;
-  ecma_value_t get_result = ecma_get_number (length_value, &length_number);
-
-  ecma_free_value (length_value);
-
-  if (ECMA_IS_VALUE_ERROR (get_result))
-  {
-    return get_result;
-  }
-  JERRY_ASSERT (ecma_is_value_empty (get_result));
-
-  /* 5. */
-  const uint32_t length = ecma_number_to_uint32 (length_number);
-
   if (length >= ECMA_FUNCTION_APPLY_ARGUMENT_COUNT_LIMIT)
   {
     return ecma_raise_range_error (ECMA_ERR_MSG ("Too many arguments declared for Function.apply()."));
@@ -142,9 +134,7 @@ ecma_builtin_function_prototype_object_apply (ecma_object_t *func_obj_p, /**< th
   /* 7. */
   for (index = 0; index < length; index++)
   {
-    ecma_string_t *curr_idx_str_p = ecma_new_ecma_string_from_uint32 (index);
-    ecma_value_t get_value = ecma_op_object_get (obj_p, curr_idx_str_p);
-    ecma_deref_ecma_string (curr_idx_str_p);
+    ecma_value_t get_value = ecma_op_object_get_by_uint32_index (obj_p, index);
 
     if (ECMA_IS_VALUE_ERROR (get_value))
     {
@@ -218,7 +208,13 @@ ecma_builtin_function_prototype_object_bind (ecma_object_t *this_arg_obj_p , /**
                                              ecma_length_t arguments_number) /**< number of arguments */
 {
   /* 4. 11. 18. */
-  ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE);
+  ecma_object_t *prototype_obj_p;
+
+#if ENABLED (JERRY_ES2015)
+  prototype_obj_p = ECMA_GET_POINTER (ecma_object_t, this_arg_obj_p->u2.prototype_cp);
+#else /* !ENABLED (JERRY_ES2015) */
+  prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE);
+#endif /* ENABLED (JERRY_ES2015) */
 
   ecma_object_t *function_p;
   ecma_extended_object_t *ext_function_p;
@@ -350,6 +346,12 @@ ecma_builtin_function_prototype_dispatch_routine (uint16_t builtin_routine_id, /
     {
       return ecma_builtin_function_prototype_object_bind (func_obj_p, arguments_list_p, arguments_number);
     }
+#if ENABLED (JERRY_ES2015)
+    case ECMA_FUNCTION_PROTOTYPE_SYMBOL_HAS_INSTANCE:
+    {
+      return ecma_op_object_has_instance (func_obj_p, arguments_list_p[0]);
+    }
+#endif /* ENABLED (JERRY_ES2015) */
     default:
     {
       JERRY_UNREACHABLE ();

jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.h

@@ -0,0 +1,23 @@
+/* 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.
+ */
+
+#ifndef ECMA_BUILTIN_FUNCTION_PROTOTYPE_H
+#define ECMA_BUILTIN_FUNCTION_PROTOTYPE_H
+
+ecma_value_t ecma_builtin_function_prototype_object_apply (ecma_object_t *func_obj_p,
+                                                           ecma_value_t arg1,
+                                                           ecma_value_t arg2);
+
+#endif /* !ECMA_BUILTIN_FUNCTION_PROTOTYPE_H */

jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.inc.h

@@ -42,4 +42,20 @@ ROUTINE (LIT_MAGIC_STRING_APPLY, ECMA_FUNCTION_PROTOTYPE_APPLY, 2, 2)
 ROUTINE (LIT_MAGIC_STRING_CALL, ECMA_FUNCTION_PROTOTYPE_CALL, NON_FIXED, 1)
 ROUTINE (LIT_MAGIC_STRING_BIND, ECMA_FUNCTION_PROTOTYPE_BIND, NON_FIXED, 1)
 
+#if ENABLED (JERRY_ES2015)
+/**
+ * ECMA-262 v6.0 19.2.3.6 @@hasInstance
+ *  the property attributes are: { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
+ */
+ROUTINE_WITH_FLAGS (LIT_GLOBAL_SYMBOL_HAS_INSTANCE, ECMA_FUNCTION_PROTOTYPE_SYMBOL_HAS_INSTANCE, 1, 1, 0 /* flags */)
+ACCESSOR_BUILTIN_FUNCTION (LIT_MAGIC_STRING_ARGUMENTS,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_PROPERTY_FLAG_CONFIGURABLE)
+ACCESSOR_BUILTIN_FUNCTION (LIT_MAGIC_STRING_CALLER,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_PROPERTY_FLAG_CONFIGURABLE)
+#endif /* ENABLED (JERRY_ES2015) */
+
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-function.c

@@ -59,60 +59,6 @@ ecma_builtin_function_dispatch_call (const ecma_value_t *arguments_list_p, /**<
   return ecma_builtin_function_dispatch_construct (arguments_list_p, arguments_list_len);
 } /* ecma_builtin_function_dispatch_call */
 
-/**
- * Helper method to count and convert the arguments for the Function constructor call.
- *
- * Performs the operation described in ECMA 262 v5.1 15.3.2.1 steps 5.a-d
- *
- *
- * @return ecma value - concatenated arguments as a string.
- *         Returned value must be freed with ecma_free_value.
- */
-static ecma_value_t
-ecma_builtin_function_helper_get_function_arguments (const ecma_value_t *arguments_list_p, /**< arguments list */
-                                                     ecma_length_t arguments_list_len) /**< number of arguments */
-{
-  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
-
-  if (arguments_list_len <= 1)
-  {
-    return ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
-  }
-
-  ecma_value_t final_str = ecma_op_to_string (arguments_list_p[0]);
-
-  if (arguments_list_len == 2 || ECMA_IS_VALUE_ERROR (final_str))
-  {
-    return final_str;
-  }
-
-  for (ecma_length_t idx = 1; idx < arguments_list_len - 1; idx++)
-  {
-    ecma_value_t new_str = ecma_op_to_string (arguments_list_p[idx]);
-
-    if (ECMA_IS_VALUE_ERROR (new_str))
-    {
-      ecma_free_value (final_str);
-
-      /* Return with the error. */
-      final_str = new_str;
-      break;
-    }
-
-    ecma_string_t *final_str_p = ecma_get_string_from_value (final_str);
-    final_str_p = ecma_append_magic_string_to_string (final_str_p,
-                                                      LIT_MAGIC_STRING_COMMA_CHAR);
-
-    ecma_string_t *new_str_p = ecma_get_string_from_value (new_str);
-    final_str_p = ecma_concat_ecma_strings (final_str_p, new_str_p);
-    ecma_deref_ecma_string (new_str_p);
-
-    final_str = ecma_make_string_value (final_str_p);
-  }
-
-  return final_str;
-} /* ecma_builtin_function_helper_get_function_arguments */
-
 /**
  * Handle calling [[Construct]] of built-in Function object
  *
@@ -125,71 +71,7 @@ ecma_value_t
 ecma_builtin_function_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
                                           ecma_length_t arguments_list_len) /**< number of arguments */
 {
-  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
-
-  ecma_value_t arguments_value = ecma_builtin_function_helper_get_function_arguments (arguments_list_p,
-                                                                                      arguments_list_len);
-
-  if (ECMA_IS_VALUE_ERROR (arguments_value))
-  {
-    return arguments_value;
-  }
-
-  ecma_value_t function_body_value;
-
-  if (arguments_list_len > 0)
-  {
-    function_body_value = ecma_op_to_string (arguments_list_p[arguments_list_len - 1]);
-
-    if (ECMA_IS_VALUE_ERROR (function_body_value))
-    {
-      ecma_free_value (arguments_value);
-      return function_body_value;
-    }
-  }
-  else
-  {
-    /* Very unlikely code path, not optimized. */
-    function_body_value = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
-  }
-
-  ecma_string_t *arguments_str_p = ecma_get_string_from_value (arguments_value);
-  ecma_string_t *function_body_str_p = ecma_get_string_from_value (function_body_value);
-
-  ECMA_STRING_TO_UTF8_STRING (arguments_str_p, arguments_buffer_p, arguments_buffer_size);
-  ECMA_STRING_TO_UTF8_STRING (function_body_str_p, function_body_buffer_p, function_body_buffer_size);
-
-#if ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ERROR_MESSAGES) || ENABLED (JERRY_ES2015_MODULE_SYSTEM)
-  JERRY_CONTEXT (resource_name) = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
-#endif /* ENABLED (JERRY_LINE_INFO) || ENABLED (JERRY_ERROR_MESSAGES) || ENABLED (JERRY_ES2015_MODULE_SYSTEM) */
-
-  ecma_compiled_code_t *bytecode_data_p = NULL;
-
-  ecma_value_t ret_value = parser_parse_script (arguments_buffer_p,
-                                                arguments_buffer_size,
-                                                function_body_buffer_p,
-                                                function_body_buffer_size,
-                                                ECMA_PARSE_NO_OPTS,
-                                                &bytecode_data_p);
-
-  if (!ECMA_IS_VALUE_ERROR (ret_value))
-  {
-    JERRY_ASSERT (ecma_is_value_true (ret_value));
-
-    ecma_object_t *func_obj_p = ecma_op_create_function_object (ecma_get_global_environment (),
-                                                                bytecode_data_p);
-
-    ecma_bytecode_deref (bytecode_data_p);
-    ret_value = ecma_make_object_value (func_obj_p);
-  }
-
-  ECMA_FINALIZE_UTF8_STRING (function_body_buffer_p, function_body_buffer_size);
-  ECMA_FINALIZE_UTF8_STRING (arguments_buffer_p, arguments_buffer_size);
-
-  ecma_deref_ecma_string (arguments_str_p);
-  ecma_deref_ecma_string (function_body_str_p);
-
-  return ret_value;
+  return ecma_op_create_dynamic_function (arguments_list_p, arguments_list_len, ECMA_PARSE_NO_OPTS);
 } /* ecma_builtin_function_dispatch_construct */
 
 /**

jerry-core/ecma/builtin-objects/ecma-builtin-generator-function.c

@@ -0,0 +1,72 @@
+/* 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 "ecma-globals.h"
+
+#if ENABLED (JERRY_ES2015)
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+#include "ecma-function-object.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-generator-function.inc.h"
+#define BUILTIN_UNDERSCORED_ID generator_function
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup generator ECMA GeneratorFunction object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in GeneratorFunction object
+ *
+ * @return constructed generator function object - if success
+ *         raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_generator_function_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                               ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_op_create_dynamic_function (arguments_list_p, arguments_list_len, ECMA_PARSE_GENERATOR_FUNCTION);
+} /* ecma_builtin_generator_function_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in GeneratorFunction object
+ *
+* @return constructed generator function object - if success
+ *        raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_generator_function_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                    ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_generator_function_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_generator_function_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-generator-function.inc.h

@@ -0,0 +1,41 @@
+/* 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.
+ */
+
+/*
+ * %GeneratorFunction% built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if ENABLED (JERRY_ES2015)
+
+/* ECMA-262 v6, 25.2.2 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME,
+              LIT_MAGIC_STRING_GENERATOR_FUNCTION_UL,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.2.2 */
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.2.2.2 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
+              ECMA_BUILTIN_ID_GENERATOR,
+              ECMA_PROPERTY_FIXED)
+
+#endif /* ENABLED (JERRY_ES2015) */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-generator-prototype.c

@@ -0,0 +1,250 @@
+/* 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 "ecma-builtins.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-iterator-object.h"
+#include "jcontext.h"
+#include "opcodes.h"
+#include "vm-defines.h"
+
+#if ENABLED (JERRY_ES2015)
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-generator-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID generator_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup generator ECMA Generator.prototype object built-in
+ * @{
+ */
+
+/**
+ * Byte code sequence which returns from the generator.
+ */
+static const uint8_t ecma_builtin_generator_prototype_return[2] =
+{
+  CBC_EXT_OPCODE, CBC_EXT_RETURN
+};
+
+/**
+ * Byte code sequence which throws an exception.
+ */
+static const uint8_t ecma_builtin_generator_prototype_throw[1] =
+{
+  CBC_THROW
+};
+
+/**
+ * Helper function for next / return / throw
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_generator_prototype_object_do (ecma_value_t this_arg, /**< this argument */
+                                            ecma_value_t arg, /**< argument */
+                                            ecma_iterator_command_type_t resume_mode) /**< resume mode */
+{
+  vm_executable_object_t *executable_object_p = NULL;
+
+  if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
+
+    if (ecma_get_object_type (object_p) == ECMA_OBJECT_TYPE_CLASS)
+    {
+      ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) object_p;
+
+      if (ext_object_p->u.class_prop.class_id == LIT_MAGIC_STRING_GENERATOR_UL)
+      {
+        executable_object_p = (vm_executable_object_t *) ext_object_p;
+      }
+    }
+  }
+
+  if (executable_object_p == NULL)
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("Argument 'this' is not a generator object."));
+  }
+
+  if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_RUNNING)
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("Generator is currently under execution."));
+  }
+
+  if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_COMPLETED)
+  {
+    return ecma_create_iter_result_object (ECMA_VALUE_UNDEFINED, ECMA_VALUE_TRUE);
+  }
+
+  arg = ecma_copy_value (arg);
+
+  while (true)
+  {
+    if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
+    {
+      ecma_value_t iterator = executable_object_p->extended_object.u.class_prop.u.value;
+
+      bool done = false;
+      ecma_value_t result = ecma_op_iterator_do (resume_mode, iterator, arg, &done);
+      ecma_free_value (arg);
+
+      if (ECMA_IS_VALUE_ERROR (result))
+      {
+        arg = result;
+      }
+      else if (done)
+      {
+        arg = ecma_op_iterator_value (result);
+        ecma_free_value (result);
+        if (resume_mode == ECMA_ITERATOR_THROW)
+        {
+          /* This part is changed in the newest ECMAScript standard.
+           * It was ECMA_ITERATOR_RETURN in ES2015, but I think it was a typo. */
+          resume_mode = ECMA_ITERATOR_NEXT;
+        }
+      }
+      else
+      {
+        return result;
+      }
+
+      executable_object_p->extended_object.u.class_prop.extra_info &= (uint16_t) ~ECMA_GENERATOR_ITERATE_AND_YIELD;
+
+      if (ECMA_IS_VALUE_ERROR (arg))
+      {
+        arg = jcontext_take_exception ();
+        resume_mode = ECMA_ITERATOR_THROW;
+      }
+    }
+
+    if (resume_mode == ECMA_ITERATOR_RETURN)
+    {
+      executable_object_p->frame_ctx.byte_code_p = ecma_builtin_generator_prototype_return;
+    }
+    else if (resume_mode == ECMA_ITERATOR_THROW)
+    {
+      executable_object_p->frame_ctx.byte_code_p = ecma_builtin_generator_prototype_throw;
+    }
+
+    ecma_value_t value = opfunc_resume_executable_object (executable_object_p, arg);
+
+    if (ECMA_IS_VALUE_ERROR (value))
+    {
+      return value;
+    }
+
+    bool done = (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_COMPLETED);
+
+    if (!done)
+    {
+      const uint8_t *byte_code_p = executable_object_p->frame_ctx.byte_code_p;
+
+      JERRY_ASSERT (byte_code_p[-2] == CBC_EXT_OPCODE
+                    && (byte_code_p[-1] == CBC_EXT_YIELD || byte_code_p[-1] == CBC_EXT_YIELD_ITERATOR));
+
+      if (byte_code_p[-1] == CBC_EXT_YIELD_ITERATOR)
+      {
+        ecma_value_t iterator = ecma_op_get_iterator (value, ECMA_VALUE_EMPTY);
+        ecma_free_value (value);
+
+        if (ECMA_IS_VALUE_ERROR (iterator))
+        {
+          resume_mode = ECMA_ITERATOR_THROW;
+          arg = jcontext_take_exception ();
+          continue;
+        }
+
+        ecma_deref_object (ecma_get_object_from_value (iterator));
+        executable_object_p->extended_object.u.class_prop.extra_info |= ECMA_GENERATOR_ITERATE_AND_YIELD;
+        executable_object_p->extended_object.u.class_prop.u.value = iterator;
+        arg = ECMA_VALUE_UNDEFINED;
+        continue;
+      }
+    }
+
+    ecma_value_t result = ecma_create_iter_result_object (value, ecma_make_boolean_value (done));
+    ecma_fast_free_value (value);
+    return result;
+  }
+} /* ecma_builtin_generator_prototype_object_do */
+
+/**
+ * The Generator.prototype object's 'next' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 25.3.1.2
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_generator_prototype_object_next (ecma_value_t this_arg, /**< this argument */
+                                              ecma_value_t next_arg) /**< next argument */
+{
+  return ecma_builtin_generator_prototype_object_do (this_arg, next_arg, ECMA_ITERATOR_NEXT);
+} /* ecma_builtin_generator_prototype_object_next */
+
+/**
+ * The Generator.prototype object's 'return' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 25.3.1.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_generator_prototype_object_return (ecma_value_t this_arg, /**< this argument */
+                                                ecma_value_t return_arg) /**< return argument */
+{
+  return ecma_builtin_generator_prototype_object_do (this_arg, return_arg, ECMA_ITERATOR_RETURN);
+} /* ecma_builtin_generator_prototype_object_return */
+
+/**
+ * The Generator.prototype object's 'throw' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 25.3.1.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_generator_prototype_object_throw (ecma_value_t this_arg, /**< this argument */
+                                                ecma_value_t throw_arg) /**< throw argument */
+{
+  return ecma_builtin_generator_prototype_object_do (this_arg, throw_arg, ECMA_ITERATOR_THROW);
+} /* ecma_builtin_generator_prototype_object_throw */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-generator-prototype.inc.h

@@ -0,0 +1,45 @@
+/* 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.
+ */
+
+/*
+ * Generator.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if ENABLED (JERRY_ES2015)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v6, 25.3.1.5 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
+              LIT_MAGIC_STRING_GENERATOR_UL,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.2.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR,
+              ECMA_BUILTIN_ID_GENERATOR,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_NEXT, ecma_builtin_generator_prototype_object_next, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_RETURN, ecma_builtin_generator_prototype_object_return, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_THROW, ecma_builtin_generator_prototype_object_throw, 1, 1)
+
+#endif /* ENABLED (JERRY_ES2015) */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-generator.c

@@ -0,0 +1,43 @@
+/* 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 "ecma-globals.h"
+
+#if ENABLED (JERRY_ES2015)
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-generator.inc.h"
+#define BUILTIN_UNDERSCORED_ID generator
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup generator ECMA Generator object built-in
+ * @{
+ */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-generator.inc.h

@@ -0,0 +1,41 @@
+/* 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.
+ */
+
+/*
+ * %Generator% built-in description (GeneratorFunction.prototype)
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if ENABLED (JERRY_ES2015)
+
+/* ECMA-262 v6, 25.3.2.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR,
+              ECMA_BUILTIN_ID_GENERATOR_FUNCTION,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.3.2.3.2 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
+              ECMA_BUILTIN_ID_GENERATOR_PROTOTYPE,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.3.2.3.3 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
+              LIT_MAGIC_STRING_GENERATOR_FUNCTION_UL,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#endif /* ENABLED (JERRY_ES2015) */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-global.c

@@ -100,12 +100,12 @@ ecma_builtin_global_object_eval (ecma_value_t x) /**< routine's first argument *
     parse_opts |= ECMA_PARSE_STRICT_MODE;
   }
 
-#if ENABLED (JERRY_ES2015_CLASS)
+#if ENABLED (JERRY_ES2015)
   if (vm_is_direct_eval_form_call ())
   {
     parse_opts |= ECMA_GET_SUPER_EVAL_PARSER_OPTS ();
   }
-#endif /* ENABLED (JERRY_ES2015_CLASS) */
+#endif /* ENABLED (JERRY_ES2015) */
 
   /* steps 2 to 8 */
   return ecma_op_eval (ecma_get_string_from_value (x), parse_opts);
@@ -150,7 +150,7 @@ ecma_builtin_global_object_parse_int (const lit_utf8_byte_t *string_buff, /**< r
   int sign = 1;
 
   /* 4. */
-  ecma_char_t current = lit_utf8_read_next (&string_curr_p);
+  ecma_char_t current = lit_cesu8_read_next (&string_curr_p);
   if (current == LIT_CHAR_MINUS)
   {
     sign = -1;
@@ -162,7 +162,7 @@ ecma_builtin_global_object_parse_int (const lit_utf8_byte_t *string_buff, /**< r
     start_p = string_curr_p;
     if (string_curr_p < string_end_p)
     {
-      current = lit_utf8_read_next (&string_curr_p);
+      current = lit_cesu8_read_next (&string_curr_p);
     }
   }
 
@@ -387,7 +387,6 @@ ecma_builtin_global_object_parse_float (const lit_utf8_byte_t *string_buff, /**<
     }
   }
 
-
   /* Set end position to the end of whole part. */
   end_p = str_curr_p;
   if (str_curr_p < str_end_p)
@@ -425,7 +424,6 @@ ecma_builtin_global_object_parse_float (const lit_utf8_byte_t *string_buff, /**<
     }
   }
 
-
   if (str_curr_p < str_end_p)
   {
     current = *str_curr_p++;
@@ -970,7 +968,7 @@ ecma_builtin_global_object_escape (lit_utf8_byte_t *input_start_p, /**< routine'
 
   while (input_curr_p < input_end_p)
   {
-    ecma_char_t chr = lit_utf8_read_next (&input_curr_p);
+    ecma_char_t chr = lit_cesu8_read_next (&input_curr_p);
 
     if (chr <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)
     {
@@ -1005,7 +1003,7 @@ ecma_builtin_global_object_escape (lit_utf8_byte_t *input_start_p, /**< routine'
 
   while (input_curr_p < input_end_p)
   {
-    ecma_char_t chr = lit_utf8_read_next (&input_curr_p);
+    ecma_char_t chr = lit_cesu8_read_next (&input_curr_p);
 
     if (chr <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)
     {
@@ -1091,7 +1089,7 @@ ecma_builtin_global_object_unescape (lit_utf8_byte_t *input_start_p, /**< routin
   while (input_curr_p < input_end_p)
   {
     /* 6. */
-    ecma_char_t chr = lit_utf8_read_next (&input_curr_p);
+    ecma_char_t chr = lit_cesu8_read_next (&input_curr_p);
 
     /* 7-8. */
     if (status == 0 && chr == LIT_CHAR_PERCENT)
@@ -1185,15 +1183,13 @@ ecma_builtin_global_dispatch_routine (uint16_t builtin_routine_id, /**< built-in
     return ecma_builtin_global_object_is_finite (arg_num);
   }
 
-  ecma_value_t string_value = ecma_op_to_string (routine_arg_1);
+  ecma_string_t *str_p = ecma_op_to_string (routine_arg_1);
 
-  if (ECMA_IS_VALUE_ERROR (string_value))
+  if (JERRY_UNLIKELY (str_p == NULL))
   {
-    return string_value;
+    return ECMA_VALUE_ERROR;
   }
 
-  ecma_string_t *str_p = ecma_get_string_from_value (string_value);
-
   ecma_value_t ret_value;
 
   if (builtin_routine_id <= ECMA_GLOBAL_PARSE_FLOAT)

jerry-core/ecma/builtin-objects/ecma-builtin-global.inc.h

@@ -139,6 +139,12 @@ OBJECT_VALUE (LIT_MAGIC_STRING_MATH_UL,
               ECMA_BUILTIN_ID_MATH,
               ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
 #endif /* ENABLED (JERRY_BUILTIN_MATH) */
+#if ENABLED (JERRY_ES2015_BUILTIN_REFLECT)
+/* ECMA-262 v6, 26.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_REFLECT_UL,
+              ECMA_BUILTIN_ID_REFLECT,
+              ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_REFLECT) */
 
 #if ENABLED (JERRY_BUILTIN_JSON)
 /* ECMA-262 v5, 15.1.5.2 */
@@ -212,12 +218,26 @@ OBJECT_VALUE (LIT_MAGIC_STRING_SET_UL,
               ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_SET) */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015_BUILTIN_WEAKMAP)
+/* ECMA-262 v6, 23.1.1.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_WEAKMAP_UL,
+              ECMA_BUILTIN_ID_WEAKMAP,
+              ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_SET) */
+
+#if ENABLED (JERRY_ES2015_BUILTIN_WEAKSET)
+/* ECMA-262 v6, 23.1.1.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_WEAKSET_UL,
+              ECMA_BUILTIN_ID_WEAKSET,
+              ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_SET) */
+
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 19.4.1.1 */
 OBJECT_VALUE (LIT_MAGIC_STRING_SYMBOL_UL,
               ECMA_BUILTIN_ID_SYMBOL,
               ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #if ENABLED (JERRY_ES2015_BUILTIN_DATAVIEW)
 /* ECMA-262 v6, 23.1.1.1 */

jerry-core/ecma/builtin-objects/ecma-builtin-helpers-date.c

@@ -33,6 +33,16 @@
  * @{
  */
 
+const char day_names_p[7][3] =
+{
+  "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+};
+
+const char month_names_p[12][3] =
+{
+  "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
 /**
  * Helper function to get day number from time value.
  *
@@ -577,16 +587,6 @@ static ecma_value_t
 ecma_date_to_string_format (ecma_number_t datetime_number, /**< datetime */
                             const char *format_p) /**< format buffer */
 {
-  static const char * const day_names_p[8] =
-  {
-    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-  };
-
-  static const char * const month_names_p[13] =
-  {
-    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-  };
-
   const uint32_t date_buffer_length = 37;
   JERRY_VLA (lit_utf8_byte_t, date_buffer, date_buffer_length);
 
@@ -696,7 +696,7 @@ ecma_date_to_string_format (ecma_number_t datetime_number, /**< datetime */
         number_length = 3;
         break;
       }
-      case LIT_CHAR_LOWERCASE_Z: /* Time zone minutes part. */
+      case LIT_CHAR_LOWERCASE_Z: /* Time zone hours part. */
       {
         int32_t time_zone = (int32_t) ecma_date_local_time_zone_adjustment (datetime_number);
 
@@ -716,7 +716,7 @@ ecma_date_to_string_format (ecma_number_t datetime_number, /**< datetime */
       }
       default:
       {
-        JERRY_ASSERT (*format_p == LIT_CHAR_UPPERCASE_Z); /* Time zone seconds part. */
+        JERRY_ASSERT (*format_p == LIT_CHAR_UPPERCASE_Z); /* Time zone minutes part. */
 
         int32_t time_zone = (int32_t) ecma_date_local_time_zone_adjustment (datetime_number);
 
@@ -725,7 +725,7 @@ ecma_date_to_string_format (ecma_number_t datetime_number, /**< datetime */
           time_zone = -time_zone;
         }
 
-        number = time_zone % (int32_t) ECMA_DATE_MS_PER_HOUR;
+        number = time_zone % (int32_t) ECMA_DATE_MS_PER_HOUR / (int32_t) ECMA_DATE_MS_PER_MINUTE;
         number_length = 2;
         break;
       }
@@ -735,13 +735,9 @@ ecma_date_to_string_format (ecma_number_t datetime_number, /**< datetime */
 
     if (str_p != NULL)
     {
-      /* Print string values. */
-      do
-      {
-        *dest_p++ = (lit_utf8_byte_t) *str_p++;
-      }
-      while (*str_p != LIT_CHAR_NULL);
-
+      /* Print string values: month or day name which is always 3 characters */
+      memcpy (dest_p, str_p, 3);
+      dest_p += 3;
       continue;
     }
 
@@ -791,7 +787,7 @@ ecma_value_t
 ecma_date_value_to_string (ecma_number_t datetime_number) /**< datetime */
 {
   datetime_number += ecma_date_local_time_zone_adjustment (datetime_number);
-  return ecma_date_to_string_format (datetime_number, "$W $M $D $Y $h:$m:$s GMT$z:$Z");
+  return ecma_date_to_string_format (datetime_number, "$W $M $D $Y $h:$m:$s GMT$z$Z");
 } /* ecma_date_value_to_string */
 
 /**

jerry-core/ecma/builtin-objects/ecma-builtin-helpers-error.c

@@ -47,20 +47,18 @@ ecma_builtin_helper_error_dispatch_call (ecma_standard_error_t error_type, /**<
   if (arguments_list_len != 0
       && !ecma_is_value_undefined (arguments_list_p[0]))
   {
-    ecma_value_t ret_value = ECMA_VALUE_EMPTY;
+    ecma_string_t *message_string_p = ecma_op_to_string (arguments_list_p[0]);
 
-    ECMA_TRY_CATCH (msg_str_value,
-                    ecma_op_to_string (arguments_list_p[0]),
-                    ret_value);
+    if (JERRY_UNLIKELY (message_string_p == NULL))
+    {
+      return ECMA_VALUE_ERROR;
+    }
 
-    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
     ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (error_type,
                                                                               message_string_p);
-    ret_value = ecma_make_object_value (new_error_object_p);
 
-    ECMA_FINALIZE (msg_str_value);
-
-    return ret_value;
+    ecma_deref_ecma_string (message_string_p);
+    return ecma_make_object_value (new_error_object_p);
   }
   else
   {
@@ -74,4 +72,3 @@ ecma_builtin_helper_error_dispatch_call (ecma_standard_error_t error_type, /**<
  * @}
  * @}
  */
-

jerry-core/ecma/builtin-objects/ecma-builtin-helpers-macro-defines.inc.h

@@ -25,11 +25,19 @@
 #define STRING_VALUE(name, magic_string_id, prop_attributes)
 #endif /* !STRING_VALUE */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 #ifndef SYMBOL_VALUE
-#define SYMBOL_VALUE(name, desc_string_id)
+#define SYMBOL_VALUE(symbol, desc_magic_string_id)
 #endif /* !SYMBOL_VALUE */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+
+#ifndef INTRINSIC_PROPERTY
+#define INTRINSIC_PROPERTY(name, magic_string_id)
+#endif /* !INTRINSIC_PROPERTY */
+
+#ifndef ACCESSOR_BUILTIN_FUNCTION_OBJECT
+#define ACCESSOR_BUILTIN_FUNCTION_OBJECT(name, getter_builtin_id, setter_builtin_id, prop_attributes)
+#endif /* !ACCESSOR_BUILTIN_FUNCTION_OBJECT */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #ifndef OBJECT_VALUE
 #define OBJECT_VALUE(name, obj_builtin_id, prop_attributes)
@@ -43,6 +51,10 @@
 #define ROUTINE_CONFIGURABLE_ONLY(name, c_function_name, args_number, length_prop_value)
 #endif /* !ROUTINE_CONFIGURABLE_ONLY */
 
+#ifndef ROUTINE_WITH_FLAGS
+#define ROUTINE_WITH_FLAGS(name, c_function_name, args_number, length_prop_value, flags)
+#endif /* !ROUTINE_WITH_FLAGS */
+
 #ifndef ACCESSOR_READ_WRITE
 #define ACCESSOR_READ_WRITE(name, c_getter_func_name, c_setter_func_name, prop_attributes)
 #endif /* !ACCESSOR_READ_WRITE */

jerry-core/ecma/builtin-objects/ecma-builtin-helpers-macro-undefs.inc.h

@@ -16,11 +16,14 @@
 #undef SIMPLE_VALUE
 #undef NUMBER_VALUE
 #undef STRING_VALUE
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 #undef SYMBOL_VALUE
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#undef INTRINSIC_PROPERTY
+#undef ACCESSOR_BUILTIN_FUNCTION_OBJECT
+#endif /* ENABLED (JERRY_ES2015) */
 #undef OBJECT_VALUE
 #undef ROUTINE
 #undef ROUTINE_CONFIGURABLE_ONLY
+#undef ROUTINE_WITH_FLAGS
 #undef ACCESSOR_READ_WRITE
 #undef ACCESSOR_READ_ONLY

jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c

@@ -27,6 +27,7 @@
 #include "ecma-objects.h"
 #include "ecma-try-catch-macro.h"
 #include "lit-magic-strings.h"
+#include "lit-char-helpers.h"
 
 /** \addtogroup ecma ECMA
  * @{
@@ -35,7 +36,7 @@
  * @{
  */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /**
  * Helper function for Object.prototype.toString routine when
  * the @@toStringTag property is present
@@ -96,7 +97,7 @@ ecma_builtin_helper_object_to_string_tag_helper (ecma_value_t tag_value) /**< st
 
   return ecma_make_string_value (ret_string_p);
 } /* ecma_builtin_helper_object_to_string_tag_helper */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Common implementation of the Object.prototype.toString routine
@@ -140,8 +141,8 @@ ecma_builtin_helper_object_to_string (const ecma_value_t this_arg) /**< this arg
 
     type_string = ecma_object_get_class_name (obj_p);
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
-    ecma_value_t tag_value = ecma_op_object_get_by_symbol_id (obj_p, LIT_MAGIC_STRING_TO_STRING_TAG);
+#if ENABLED (JERRY_ES2015)
+    ecma_value_t tag_value = ecma_op_object_get_by_symbol_id (obj_p, LIT_GLOBAL_SYMBOL_TO_STRING_TAG);
 
     if (ECMA_IS_VALUE_ERROR (tag_value))
     {
@@ -156,7 +157,7 @@ ecma_builtin_helper_object_to_string (const ecma_value_t this_arg) /**< this arg
     }
 
     ecma_free_value (tag_value);
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
     ecma_deref_object (obj_p);
   }
@@ -201,63 +202,68 @@ ecma_builtin_helper_object_to_string (const ecma_value_t this_arg) /**< this arg
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-ecma_value_t
+ecma_string_t *
 ecma_builtin_helper_get_to_locale_string_at_index (ecma_object_t *obj_p, /**< this object */
                                                    uint32_t index) /**< array index */
 {
-  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
-  ecma_string_t *index_string_p = ecma_new_ecma_string_from_uint32 (index);
+  ecma_value_t index_value = ecma_op_object_get_by_uint32_index (obj_p, index);
 
-  ECMA_TRY_CATCH (index_value,
-                  ecma_op_object_get (obj_p, index_string_p),
-                  ret_value);
+  if (ECMA_IS_VALUE_ERROR (index_value))
+  {
+    return NULL;
+  }
 
   if (ecma_is_value_undefined (index_value) || ecma_is_value_null (index_value))
   {
-    ret_value = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
+    return ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
   }
-  else
+
+  ecma_value_t index_obj_value = ecma_op_to_object (index_value);
+
+  if (ECMA_IS_VALUE_ERROR (index_obj_value))
   {
-    ECMA_TRY_CATCH (index_obj_value,
-                    ecma_op_to_object (index_value),
-                    ret_value);
-
-    ecma_object_t *index_obj_p = ecma_get_object_from_value (index_obj_value);
-
-    ECMA_TRY_CATCH (to_locale_value,
-                    ecma_op_object_get_by_magic_id (index_obj_p, LIT_MAGIC_STRING_TO_LOCALE_STRING_UL),
-                    ret_value);
-
-    if (ecma_op_is_callable (to_locale_value))
-    {
-      ecma_object_t *locale_func_obj_p = ecma_get_object_from_value (to_locale_value);
-      ECMA_TRY_CATCH (call_value,
-                      ecma_op_function_call (locale_func_obj_p,
-                                             ecma_make_object_value (index_obj_p),
-                                             NULL,
-                                             0),
-                      ret_value);
-      ret_value = ecma_op_to_string (call_value);
-      ECMA_FINALIZE (call_value);
-
-    }
-    else
-    {
-      ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("'toLocaleString' is missing or not a function."));
-    }
-
-    ECMA_FINALIZE (to_locale_value);
-    ECMA_FINALIZE (index_obj_value);
+    ecma_free_value (index_value);
+    return NULL;
   }
 
-  ECMA_FINALIZE (index_value);
+  ecma_string_t *ret_string_p = NULL;
+  ecma_object_t *index_obj_p = ecma_get_object_from_value (index_obj_value);
+  ecma_value_t to_locale_value = ecma_op_object_get_by_magic_id (index_obj_p, LIT_MAGIC_STRING_TO_LOCALE_STRING_UL);
 
-  ecma_deref_ecma_string (index_string_p);
+  if (ECMA_IS_VALUE_ERROR (to_locale_value))
+  {
+    goto cleanup;
+  }
 
-  return ret_value;
+  if (!ecma_op_is_callable (to_locale_value))
+  {
+    ecma_free_value (to_locale_value);
+    ecma_raise_type_error (ECMA_ERR_MSG ("'toLocaleString' is missing or not a function."));
+    goto cleanup;
+  }
+
+  ecma_object_t *locale_func_obj_p = ecma_get_object_from_value (to_locale_value);
+  ecma_value_t call_value = ecma_op_function_call (locale_func_obj_p,
+                                                   index_obj_value,
+                                                   NULL,
+                                                   0);
+  ecma_deref_object (locale_func_obj_p);
+
+  if (ECMA_IS_VALUE_ERROR (call_value))
+  {
+    goto cleanup;
+  }
+
+  ret_string_p = ecma_op_to_string (call_value);
+  ecma_free_value (call_value);
+
+cleanup:
+  ecma_deref_object (index_obj_p);
+  ecma_free_value (index_value);
+
+  return ret_string_p;
 } /* ecma_builtin_helper_get_to_locale_string_at_index */
 
-
 /**
  * The Object.keys and Object.getOwnPropertyNames routine's common part.
  *
@@ -286,7 +292,7 @@ ecma_builtin_helper_object_get_properties (ecma_object_t *obj_p, /**< object */
     return new_array;
   }
 
-  JERRY_ASSERT (((ecma_extended_object_t *) new_array_p)->u.array.is_fast_mode);
+  JERRY_ASSERT (ecma_op_object_is_fast_array (new_array_p));
 
   ecma_value_t *buffer_p = props_p->buffer_p;
   ecma_value_t *values_p = ecma_fast_array_extend (new_array_p, props_p->item_count);
@@ -301,93 +307,49 @@ ecma_builtin_helper_object_get_properties (ecma_object_t *obj_p, /**< object */
 /**
  * Helper function to normalizing an array index
  *
- * This function clamps the given index to the [0, length] range.
- * If the index is negative, it is used as the offset from the end of the array,
- * to compute normalized index.
- * If the index is greater than the length of the array, the normalized index will be the length of the array.
- * If is_last_index_of is true, then we use the method in ECMA-262 v6, 22.2.3.16 to compute the normalized index.
  * See also:
- *          ECMA-262 v5, 15.4.4.10 steps 5-6, 7 (part 2) and 8
- *          ECMA-262 v5, 15.4.4.12 steps 5-6
- *          ECMA-262 v5, 15.4.4.14 steps 5
- *          ECMA-262 v5, 15.5.4.13 steps 4, 5 (part 2) and 6-7
+ *          ECMA-262 v5, 15.4.4.10 steps 5, 6, 7 part 2, 8
+ *          ECMA-262 v5, 15.4.4.12 steps 5, 6
+ *          ECMA-262 v5, 15.5.4.13 steps 4 - 7
+ *          ECMA-262 v6, 22.1.3.6 steps 5 - 7, 8 part 2, 9, 10
+ *          ECMA-262 v6, 22.1.3.3 steps 5 - 10, 11 part 2, 12, 13
+ *          ECMA-262 v6, 22.2.3.5 steps 5 - 10, 11 part 2, 12, 13
+ *          ECMA-262 v6, 22.2.3.23 steps 5 - 10
+ *          ECMA-262 v6, 24.1.4.3 steps 6 - 8, 9 part 2, 10, 11
+ *          ECMA-262 v6, 22.2.3.26 steps 7 - 9, 10 part 2, 11, 12
+ *          ECMA-262 v6, 22.2.3.8 steps 5 - 7, 8 part 2, 9, 10
  *
  * Used by:
  *         - The Array.prototype.slice routine.
  *         - The Array.prototype.splice routine.
- *         - The Array.prototype.indexOf routine.
  *         - The String.prototype.slice routine.
- *         - The TypedArray.prototype.indexOf routine.
- *         - The TypedArray.prototype.lastIndexOf routine
+ *         - The Array.prototype.fill routine.
+ *         - The Array.prototype.copyWithin routine.
+ *         - The TypedArray.prototype.copyWithin routine.
+ *         - The TypedArray.prototype.slice routine.
+ *         - The ArrayBuffer.prototype.slice routine.
+ *         - The TypedArray.prototype.subarray routine.
+ *         - The TypedArray.prototype.fill routine.
  *
- * @return uint32_t - the normalized value of the index
+ * @return ECMA_VALUE_EMPTY if successful
+ *         conversion error otherwise
  */
 uint32_t
-ecma_builtin_helper_array_index_normalize (ecma_number_t index, /**< index */
+ecma_builtin_helper_array_index_normalize (ecma_value_t arg, /**< index */
                                            uint32_t length, /**< array's length */
-                                           bool is_last_index_of) /**< true - normalize for lastIndexOf method*/
+                                           uint32_t *number_p) /**< [out] uint32_t */
 {
-  uint32_t norm_index;
+  ecma_number_t to_int;
 
-  if (!ecma_number_is_nan (index))
+  if (ECMA_IS_VALUE_ERROR (ecma_op_to_integer (arg, &to_int)))
   {
-
-    if (ecma_number_is_zero (index))
-    {
-      norm_index = 0;
-    }
-    else if (ecma_number_is_infinity (index))
-    {
-      if (is_last_index_of)
-      {
-        norm_index = ecma_number_is_negative (index) ? (uint32_t) -1 : length - 1;
-      }
-      else
-      {
-        norm_index = ecma_number_is_negative (index) ? 0 : length;
-      }
-    }
-    else
-    {
-      if (ecma_number_is_negative (index))
-      {
-        ecma_number_t index_neg = -index;
-
-        if (is_last_index_of)
-        {
-          norm_index = length - ecma_number_to_uint32 (index_neg);
-        }
-        else
-        {
-          if (index_neg > length)
-          {
-            norm_index = 0;
-          }
-          else
-          {
-            norm_index = length - ecma_number_to_uint32 (index_neg);
-          }
-        }
-      }
-      else
-      {
-        if (index > length)
-        {
-          norm_index = is_last_index_of ? length - 1 : length;
-        }
-        else
-        {
-          norm_index = ecma_number_to_uint32 (index);
-        }
-      }
-    }
-  }
-  else
-  {
-    norm_index = 0;
+    return ECMA_VALUE_ERROR;
   }
 
-  return norm_index;
+  *number_p = ((to_int < 0) ? (uint32_t) JERRY_MAX ((length + to_int), 0)
+                            : (uint32_t) JERRY_MIN (to_int, length));
+
+  return ECMA_VALUE_EMPTY;
 } /* ecma_builtin_helper_array_index_normalize */
 
 /**
@@ -403,80 +365,80 @@ ecma_builtin_helper_array_index_normalize (ecma_number_t index, /**< index */
  *         Returned value must be freed with ecma_free_value.
  */
 ecma_value_t
-ecma_builtin_helper_array_concat_value (ecma_object_t *obj_p, /**< array */
+ecma_builtin_helper_array_concat_value (ecma_object_t *array_obj_p, /**< array */
                                         uint32_t *length_p, /**< [in,out] array's length */
                                         ecma_value_t value) /**< value to concat */
 {
-  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
-
   /* 5.b */
-  if (ecma_is_value_object (value)
-      && (ecma_object_get_class_name (ecma_get_object_from_value (value)) == LIT_MAGIC_STRING_ARRAY_UL))
+#if ENABLED (JERRY_ES2015)
+  ecma_value_t is_spreadable = ecma_op_is_concat_spreadable (value);
+
+  if (ECMA_IS_VALUE_ERROR (is_spreadable))
   {
-    /* 5.b.ii */
-    ECMA_TRY_CATCH (arg_len_value,
-                    ecma_op_object_get_by_magic_id (ecma_get_object_from_value (value),
-                                                    LIT_MAGIC_STRING_LENGTH),
-                    ret_value);
-    ECMA_OP_TO_NUMBER_TRY_CATCH (arg_len_number, arg_len_value, ret_value);
+    return is_spreadable;
+  }
 
-    uint32_t arg_len = ecma_number_to_uint32 (arg_len_number);
+  bool spread_object = is_spreadable == ECMA_VALUE_TRUE;
+#else /* !ENABLED (JERRY_ES2015) */
+  bool spread_object = ecma_is_value_array (value);
+#endif /* ENABLED (JERRY_ES2015) */
 
-    /* 5.b.iii */
-    for (uint32_t array_index = 0;
-         array_index < arg_len && ecma_is_value_empty (ret_value);
-         array_index++)
+  if (spread_object)
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (value);
+
+#if ENABLED (JERRY_ES2015)
+    uint32_t arg_len;
+    ecma_value_t error = ecma_op_object_get_length (obj_p, &arg_len);
+
+    if (ECMA_IS_VALUE_ERROR (error))
+    {
+      return error;
+    }
+#else /* !ENABLED (JERRY_ES2015) */
+    /* 5.b.ii */
+    uint32_t arg_len = ecma_array_get_length (obj_p);
+#endif /* ENABLED (JERRY_ES2015) */
+    /* 5.b.iii */
+    for (uint32_t array_index = 0; array_index < arg_len; array_index++)
     {
-      ecma_string_t *array_index_string_p = ecma_new_ecma_string_from_uint32 (array_index);
-
       /* 5.b.iii.2 */
-      ECMA_TRY_CATCH (get_value,
-                      ecma_op_object_find (ecma_get_object_from_value (value),
-                                           array_index_string_p),
-                      ret_value);
+      ecma_value_t get_value = ecma_op_object_find_by_uint32_index (obj_p, array_index);
 
-      if (ecma_is_value_found (get_value))
+      if (ECMA_IS_VALUE_ERROR (get_value))
       {
-        /* 5.b.iii.3.a */
-        ecma_string_t *new_array_index_string_p = ecma_new_ecma_string_from_uint32 (*length_p + array_index);
-
-        /* 5.b.iii.3.b */
-        /* This will always be a simple value since 'is_throw' is false, so no need to free. */
-        ecma_value_t put_comp = ecma_builtin_helper_def_prop (obj_p,
-                                                              new_array_index_string_p,
-                                                              get_value,
-                                                              ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
-
-        JERRY_ASSERT (ecma_is_value_true (put_comp));
-        ecma_deref_ecma_string (new_array_index_string_p);
+        return get_value;
       }
 
-      ECMA_FINALIZE (get_value);
+      if (!ecma_is_value_found (get_value))
+      {
+        continue;
+      }
 
-      ecma_deref_ecma_string (array_index_string_p);
+      /* 5.b.iii.3.b */
+      /* This will always be a simple value since 'is_throw' is false, so no need to free. */
+      ecma_value_t put_comp = ecma_builtin_helper_def_prop_by_index (array_obj_p,
+                                                                     *length_p + array_index,
+                                                                     get_value,
+                                                                     ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
+
+      JERRY_ASSERT (ecma_is_value_true (put_comp));
+      ecma_free_value (get_value);
     }
 
     *length_p += arg_len;
-
-    ECMA_OP_TO_NUMBER_FINALIZE (arg_len_number);
-    ECMA_FINALIZE (arg_len_value);
-  }
-  else
-  {
-    ecma_string_t *new_array_index_string_p = ecma_new_ecma_string_from_uint32 ((*length_p)++);
-
-    /* 5.c.i */
-    /* This will always be a simple value since 'is_throw' is false, so no need to free. */
-    ecma_value_t put_comp = ecma_builtin_helper_def_prop (obj_p,
-                                                          new_array_index_string_p,
-                                                          value,
-                                                          ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
-    JERRY_ASSERT (ecma_is_value_true (put_comp));
-
-    ecma_deref_ecma_string (new_array_index_string_p);
+    return ECMA_VALUE_EMPTY;
   }
 
-  return ret_value;
+  /* 5.c.i */
+  /* This will always be a simple value since 'is_throw' is false, so no need to free. */
+  ecma_value_t put_comp = ecma_builtin_helper_def_prop_by_index (array_obj_p,
+                                                                 (*length_p)++,
+                                                                 value,
+                                                                 ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
+  JERRY_ASSERT (ecma_is_value_true (put_comp));
+
+  return ECMA_VALUE_EMPTY;
 } /* ecma_builtin_helper_array_concat_value */
 
 /**
@@ -559,31 +521,48 @@ ecma_builtin_helper_string_prototype_object_index_of (ecma_string_t *original_st
   /* 5 (indexOf) -- 6 (lastIndexOf) */
   const ecma_length_t original_len = ecma_string_get_length (original_str_p);
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
   /* 4, 6 (startsWith, includes, endsWith) */
-  if (mode >= ECMA_STRING_STARTS_WITH
-      && (ecma_is_value_object (arg1)
-      && ecma_object_class_is (ecma_get_object_from_value (arg1), LIT_MAGIC_STRING_REGEXP_UL)))
+  if (mode >= ECMA_STRING_STARTS_WITH)
   {
-    JERRY_ASSERT (ECMA_STRING_LAST_INDEX_OF < mode && mode <= ECMA_STRING_ENDS_WITH);
-    return ecma_raise_type_error (ECMA_ERR_MSG ("Search string can't be of type: RegExp"));
-  }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+    ecma_value_t regexp = ecma_op_is_regexp (arg1);
 
-  /* 3 */
-  ecma_value_t search_str_val = ecma_op_to_string (arg1);
+    if (ECMA_IS_VALUE_ERROR (regexp))
+    {
+      return regexp;
+    }
 
-  if (ECMA_IS_VALUE_ERROR (search_str_val))
-  {
-    return search_str_val;
+    if (regexp == ECMA_VALUE_TRUE)
+    {
+      JERRY_ASSERT (ECMA_STRING_LAST_INDEX_OF < mode && mode <= ECMA_STRING_ENDS_WITH);
+      return ecma_raise_type_error (ECMA_ERR_MSG ("Search string can't be of type: RegExp"));
+    }
   }
+#endif /* ENABLED (JERRY_ES2015) */
 
   /* 7, 8 */
-  ecma_string_t *search_str_p = ecma_get_string_from_value (search_str_val);
+  ecma_string_t *search_str_p = ecma_op_to_string (arg1);
+
+  if (JERRY_UNLIKELY (search_str_p == NULL))
+  {
+    return ECMA_VALUE_ERROR;
+  }
 
   /* 4 (indexOf, lastIndexOf), 9 (startsWith, includes), 10 (endsWith) */
   ecma_number_t pos_num;
-  ecma_value_t ret_value  = ecma_get_number (arg2, &pos_num);
+  ecma_value_t ret_value;
+#if ENABLED (JERRY_ES2015)
+  if (mode > ECMA_STRING_LAST_INDEX_OF)
+  {
+    ret_value = ecma_op_to_integer (arg2, &pos_num);
+  }
+  else
+  {
+#endif /* ENABLED (JERRY_ES2015) */
+    ret_value = ecma_get_number (arg2, &pos_num);
+#if ENABLED (JERRY_ES2015)
+  }
+#endif /* ENABLED (JERRY_ES2015) */
 
   /* 10 (startsWith, includes), 11 (endsWith) */
   if (ECMA_IS_VALUE_ERROR (ret_value))
@@ -605,7 +584,7 @@ ecma_builtin_helper_string_prototype_object_index_of (ecma_string_t *original_st
 
   switch (mode)
   {
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
     case ECMA_STRING_STARTS_WITH:
     {
       if (pos_num + start > original_len)
@@ -656,7 +635,7 @@ ecma_builtin_helper_string_prototype_object_index_of (ecma_string_t *original_st
       }
       break;
     }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+#endif /* ENABLED (JERRY_ES2015) */
 
     case ECMA_STRING_INDEX_OF:
     case ECMA_STRING_LAST_INDEX_OF:
@@ -732,7 +711,7 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index
 
       /* iterate original string and try to match at each position */
       bool searching = true;
-      ecma_char_t first_char = lit_utf8_read_next (&search_str_curr_p);
+      ecma_char_t first_char = lit_cesu8_read_next (&search_str_curr_p);
       while (searching)
       {
         /* match as long as possible */
@@ -741,14 +720,14 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index
 
         if (match_len < search_len &&
             index + match_len < original_len &&
-            lit_utf8_read_next (&original_str_curr_p) == first_char)
+            lit_cesu8_read_next (&original_str_curr_p) == first_char)
         {
           const lit_utf8_byte_t *nested_search_str_curr_p = search_str_curr_p;
           match_len++;
 
           while (match_len < search_len &&
                  index + match_len < original_len &&
-                 lit_utf8_read_next (&original_str_curr_p) == lit_utf8_read_next (&nested_search_str_curr_p))
+                 lit_cesu8_read_next (&original_str_curr_p) == lit_cesu8_read_next (&nested_search_str_curr_p))
           {
             match_len++;
           }
@@ -854,6 +833,185 @@ ecma_builtin_helper_def_prop (ecma_object_t *obj_p, /**< object */
                                              &prop_desc);
 } /* ecma_builtin_helper_def_prop */
 
+/**
+ * GetSubstitution abstract operation
+ *
+ * See:
+ *     ECMA-262 v6.0 21.1.3.14.1
+ */
+void
+ecma_builtin_replace_substitute (ecma_replace_context_t *ctx_p) /**< replace context */
+{
+  JERRY_ASSERT (ctx_p->string_p != NULL);
+  JERRY_ASSERT (ctx_p->matched_p == NULL
+                || (ctx_p->matched_p >= ctx_p->string_p
+                    && ctx_p->matched_p <= ctx_p->string_p + ctx_p->string_size));
+
+  lit_utf8_size_t replace_size;
+  uint8_t replace_flags = ECMA_STRING_FLAG_IS_ASCII;
+  const lit_utf8_byte_t *replace_buf_p = ecma_string_get_chars (ctx_p->replace_str_p,
+                                                                &replace_size,
+                                                                NULL,
+                                                                NULL,
+                                                                &replace_flags);
+
+  const lit_utf8_byte_t *const replace_end_p = replace_buf_p + replace_size;
+  const lit_utf8_byte_t *curr_p = replace_buf_p;
+  const lit_utf8_byte_t *last_inserted_end_p = replace_buf_p;
+
+  while (curr_p < replace_end_p)
+  {
+    if (*curr_p++ == LIT_CHAR_DOLLAR_SIGN)
+    {
+      ecma_stringbuilder_append_raw (&(ctx_p->builder),
+                                     last_inserted_end_p,
+                                     (lit_utf8_size_t) (curr_p - last_inserted_end_p - 1));
+      if (curr_p >= replace_end_p)
+      {
+        last_inserted_end_p = curr_p - 1;
+        break;
+      }
+
+      const lit_utf8_byte_t c = *curr_p++;
+
+      switch (c)
+      {
+        case LIT_CHAR_DOLLAR_SIGN:
+        {
+          ecma_stringbuilder_append_byte (&(ctx_p->builder), LIT_CHAR_DOLLAR_SIGN);
+          break;
+        }
+        case LIT_CHAR_AMPERSAND:
+        {
+#if ENABLED (JERRY_ES2015)
+          if (JERRY_UNLIKELY (ctx_p->matched_p == NULL))
+          {
+            JERRY_ASSERT (ctx_p->capture_count == 0);
+            JERRY_ASSERT (ctx_p->u.collection_p != NULL);
+            JERRY_ASSERT (ctx_p->u.collection_p->item_count > 0);
+            const ecma_value_t match_value = ctx_p->u.collection_p->buffer_p[0];
+
+            JERRY_ASSERT (ecma_is_value_string (match_value));
+            ecma_stringbuilder_append (&(ctx_p->builder), ecma_get_string_from_value (match_value));
+            break;
+          }
+#endif /* ENABLED (JERRY_ES2015) */
+
+          JERRY_ASSERT (ctx_p->matched_p != NULL);
+          ecma_stringbuilder_append_raw (&(ctx_p->builder), ctx_p->matched_p, ctx_p->matched_size);
+          break;
+        }
+        case LIT_CHAR_GRAVE_ACCENT:
+        {
+          ecma_stringbuilder_append_raw (&(ctx_p->builder), ctx_p->string_p, ctx_p->match_byte_pos);
+          break;
+        }
+        case LIT_CHAR_SINGLE_QUOTE:
+        {
+#if ENABLED (JERRY_ES2015)
+          if (JERRY_UNLIKELY (ctx_p->matched_p == NULL))
+          {
+            JERRY_ASSERT (ctx_p->capture_count == 0);
+            JERRY_ASSERT (ctx_p->u.collection_p != NULL);
+            JERRY_ASSERT (ctx_p->u.collection_p->item_count > 0);
+            const ecma_value_t match_value = ctx_p->u.collection_p->buffer_p[0];
+
+            JERRY_ASSERT (ecma_is_value_string (match_value));
+            const ecma_string_t *const matched_p = ecma_get_string_from_value (match_value);
+            const lit_utf8_size_t match_size = ecma_string_get_size (matched_p);
+            const lit_utf8_byte_t *const begin_p = ctx_p->string_p + ctx_p->match_byte_pos + match_size;
+
+            ecma_stringbuilder_append_raw (&(ctx_p->builder),
+                                           begin_p,
+                                           (lit_utf8_size_t) (ctx_p->string_p + ctx_p->string_size - begin_p));
+            break;
+          }
+#endif /* ENABLED (JERRY_ES2015) */
+
+          JERRY_ASSERT (ctx_p->matched_p != NULL);
+          ecma_stringbuilder_append_raw (&(ctx_p->builder),
+                                         ctx_p->matched_p + ctx_p->matched_size,
+                                         ctx_p->string_size - ctx_p->match_byte_pos - ctx_p->matched_size);
+          break;
+        }
+        default:
+        {
+          const lit_utf8_byte_t *const number_begin_p = curr_p - 1;
+
+          if (lit_char_is_decimal_digit (c))
+          {
+            uint32_t capture_count = ctx_p->capture_count;
+#if ENABLED (JERRY_ES2015)
+            if (capture_count == 0 && ctx_p->u.collection_p != NULL)
+            {
+              capture_count = ctx_p->u.collection_p->item_count;
+            }
+#endif /* ENABLED (JERRY_ES2015) */
+
+            uint8_t idx = (uint8_t) (c - LIT_CHAR_0);
+            if (curr_p < replace_end_p && lit_char_is_decimal_digit (*(curr_p)))
+            {
+              uint8_t two_digit_index = (uint8_t) (idx * 10 + (uint8_t) (*(curr_p) - LIT_CHAR_0));
+              if (two_digit_index < capture_count)
+              {
+                idx = two_digit_index;
+                curr_p++;
+              }
+            }
+
+            if (idx > 0 && idx < capture_count)
+            {
+              if (ctx_p->capture_count > 0)
+              {
+#if ENABLED (JERRY_BUILTIN_REGEXP)
+                JERRY_ASSERT (ctx_p->u.captures_p != NULL);
+                const ecma_regexp_capture_t *const capture_p = ctx_p->u.captures_p + idx;
+
+                if (ECMA_RE_IS_CAPTURE_DEFINED (capture_p))
+                {
+                  ecma_stringbuilder_append_raw (&(ctx_p->builder),
+                                                 capture_p->begin_p,
+                                                 (lit_utf8_size_t) (capture_p->end_p - capture_p->begin_p));
+                }
+
+                break;
+#endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
+              }
+#if ENABLED (JERRY_ES2015)
+              else if (ctx_p->u.collection_p != NULL)
+              {
+                const ecma_value_t capture_value = ctx_p->u.collection_p->buffer_p[idx];
+                if (!ecma_is_value_undefined (capture_value))
+                {
+                  ecma_stringbuilder_append (&(ctx_p->builder), ecma_get_string_from_value (capture_value));
+                }
+
+                break;
+              }
+#endif /* ENABLED (JERRY_ES2015) */
+            }
+          }
+
+          ecma_stringbuilder_append_byte (&(ctx_p->builder), LIT_CHAR_DOLLAR_SIGN);
+          curr_p = number_begin_p;
+          break;
+        }
+      }
+
+      last_inserted_end_p = curr_p;
+    }
+  }
+
+  ecma_stringbuilder_append_raw (&(ctx_p->builder),
+                                 last_inserted_end_p,
+                                 (lit_utf8_size_t) (replace_end_p - last_inserted_end_p));
+
+  if (replace_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
+  {
+    jmem_heap_free_block ((void *) replace_buf_p, replace_size);
+  }
+} /* ecma_builtin_replace_substitute */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-helpers.h

@@ -18,6 +18,8 @@
 
 #include "ecma-globals.h"
 #include "ecma-exceptions.h"
+#include "ecma-helpers.h"
+#include "ecma-regexp-object.h"
 
 /** \addtogroup ecma ECMA
  * @{
@@ -32,8 +34,8 @@
 typedef enum
 {
   /** These routines must be in this order */
-  ECMA_STRING_INDEX_OF, /**< String.indexOf: ECMA-262 v5, 15.5.4.7 */
   ECMA_STRING_LAST_INDEX_OF, /**< String.lastIndexOf: ECMA-262 v5, 15.5.4.8 */
+  ECMA_STRING_INDEX_OF, /**< String.indexOf: ECMA-262 v5, 15.5.4.7 */
   ECMA_STRING_STARTS_WITH, /**< String.startsWith: ECMA-262 v6, 21.1.3.18 */
   ECMA_STRING_INCLUDES, /**< String.includes: ECMA-262 v6, 21.1.3.7 */
   ECMA_STRING_ENDS_WITH /**< String.includes: ECMA-262 v6, 21.1.3.6 */
@@ -41,14 +43,14 @@ typedef enum
 
 ecma_value_t
 ecma_builtin_helper_object_to_string (const ecma_value_t this_arg);
-ecma_value_t
+ecma_string_t *
 ecma_builtin_helper_get_to_locale_string_at_index (ecma_object_t *obj_p, uint32_t index);
 ecma_value_t
 ecma_builtin_helper_object_get_properties (ecma_object_t *obj_p, uint32_t opts);
 ecma_value_t
 ecma_builtin_helper_array_concat_value (ecma_object_t *obj_p, uint32_t *length_p, ecma_value_t value);
 uint32_t
-ecma_builtin_helper_array_index_normalize (ecma_number_t index, uint32_t length, bool last_index_of);
+ecma_builtin_helper_array_index_normalize (ecma_value_t arg, uint32_t length, uint32_t *number_p);
 uint32_t
 ecma_builtin_helper_string_index_normalize (ecma_number_t index, uint32_t length, bool nan_to_zero);
 ecma_value_t
@@ -63,6 +65,42 @@ ecma_builtin_helper_def_prop (ecma_object_t *obj_p, ecma_string_t *index_p, ecma
 ecma_value_t
 ecma_builtin_helper_def_prop_by_index (ecma_object_t *obj_p, uint32_t index, ecma_value_t value, uint32_t opts);
 
+/**
+ * Context for replace substitutions
+ */
+typedef struct
+{
+  ecma_stringbuilder_t builder;      /**< result string builder */
+  const lit_utf8_byte_t *string_p;   /**< source string */
+  lit_utf8_size_t string_size;       /**< source string size */
+  const lit_utf8_byte_t *matched_p;  /**< matched string */
+  lit_utf8_size_t matched_size;      /**< matcehd string size */
+  lit_utf8_size_t match_byte_pos;    /**< byte position of the match in the source string */
+  ecma_length_t index;               /**< current match index */
+
+  /**
+   * Capture results
+   */
+  union
+  {
+#if ENABLED (JERRY_BUILTIN_REGEXP)
+    const ecma_regexp_capture_t *captures_p; /**< array of regexp capturing groups */
+#endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
+    const ecma_collection_t *collection_p;   /**< collection of captured substrings */
+  } u;
+
+  uint32_t capture_count;            /**< number of captures in the capturing group array */
+  ecma_string_t *replace_str_p;      /**< replacement string */
+} ecma_replace_context_t;
+
+void
+ecma_builtin_replace_substitute (ecma_replace_context_t *ctx_p);
+
+#if ENABLED (JERRY_ES2015)
+bool
+ecma_builtin_is_regexp_exec (ecma_extended_object_t *obj_p);
+#endif /* ENABLED (JERRY_ES2015) */
+
 #if ENABLED (JERRY_BUILTIN_DATE)
 
 /**
@@ -109,6 +147,9 @@ typedef enum
 } ecma_date_timezone_t;
 
 /* ecma-builtin-helpers-date.c */
+extern const char day_names_p[7][3];
+extern const char month_names_p[12][3];
+
 ecma_number_t ecma_date_day (ecma_number_t time);
 ecma_number_t ecma_date_time_within_day (ecma_number_t time);
 ecma_number_t ecma_date_year_from_time (ecma_number_t time);

jerry-core/ecma/builtin-objects/ecma-builtin-internal-routines-template.inc.h

@@ -45,6 +45,8 @@
   static ecma_value_t c_function_name (ROUTINE_ARG_LIST_ ## args_number);
 #define ROUTINE_CONFIGURABLE_ONLY(name, c_function_name, args_number, length_prop_value) \
   static ecma_value_t c_function_name (ROUTINE_ARG_LIST_ ## args_number);
+#define ROUTINE_WITH_FLAGS(name, c_function_name, args_number, length_prop_value, flags) \
+  static ecma_value_t c_function_name (ROUTINE_ARG_LIST_ ## args_number);
 #define ACCESSOR_READ_WRITE(name, c_getter_func_name, c_setter_func_name, prop_attributes) \
   static ecma_value_t c_getter_func_name (ROUTINE_ARG_LIST_0); \
   static ecma_value_t c_setter_func_name (ROUTINE_ARG_LIST_1);
@@ -68,6 +70,8 @@ enum
   ECMA_ROUTINE_ ## name ## c_function_name,
 #define ROUTINE_CONFIGURABLE_ONLY(name, c_function_name, args_number, length_prop_value) \
   ECMA_ROUTINE_ ## name ## c_function_name,
+#define ROUTINE_WITH_FLAGS(name, c_function_name, args_number, length_prop_value, flags) \
+  ECMA_ROUTINE_ ## name ## c_function_name,
 #define ACCESSOR_READ_WRITE(name, c_getter_func_name, c_setter_func_name, prop_attributes) \
   ECMA_ACCESSOR_ ## name ## c_getter_func_name, \
   ECMA_ACCESSOR_ ## name ## c_setter_func_name,
@@ -98,6 +102,13 @@ const ecma_builtin_property_descriptor_t PROPERTY_DESCRIPTOR_LIST_NAME[] =
     ECMA_PROPERTY_FLAG_CONFIGURABLE, \
     ECMA_ROUTINE_VALUE (ECMA_ROUTINE_ ## name ## c_function_name, length_prop_value) \
   },
+#define ROUTINE_WITH_FLAGS(name, c_function_name, args_number, length_prop_value, flags) \
+  { \
+    name, \
+    ECMA_BUILTIN_PROPERTY_ROUTINE, \
+    flags, \
+    ECMA_ROUTINE_VALUE (ECMA_ROUTINE_ ## name ## c_function_name, length_prop_value) \
+  },
 #define ACCESSOR_READ_ONLY(name, c_getter_func_name, prop_attributes) \
   { \
     name, \
@@ -120,6 +131,13 @@ const ecma_builtin_property_descriptor_t PROPERTY_DESCRIPTOR_LIST_NAME[] =
     ECMA_PROPERTY_FLAG_CONFIGURABLE, \
     ECMA_ROUTINE_VALUE (c_function_name, length_prop_value) \
   },
+#define ROUTINE_WITH_FLAGS(name, c_function_name, args_number, length_prop_value, flags) \
+  { \
+    name, \
+    ECMA_BUILTIN_PROPERTY_ROUTINE, \
+    flags, \
+    ECMA_ROUTINE_VALUE (c_function_name, length_prop_value) \
+  },
 #define ACCESSOR_READ_ONLY(name, c_getter_func_name, prop_attributes) \
   { \
     name, \
@@ -156,15 +174,29 @@ const ecma_builtin_property_descriptor_t PROPERTY_DESCRIPTOR_LIST_NAME[] =
     prop_attributes, \
     magic_string_id \
   },
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
-#define SYMBOL_VALUE(name, desc_string_id) \
+#if ENABLED (JERRY_ES2015)
+#define SYMBOL_VALUE(symbol, desc_magic_string_id) \
   { \
-    name, \
+    symbol, \
     ECMA_BUILTIN_PROPERTY_SYMBOL, \
     ECMA_PROPERTY_FIXED, \
-    desc_string_id \
+    desc_magic_string_id \
   },
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#define INTRINSIC_PROPERTY(name, magic_string_id) \
+  { \
+    name, \
+    ECMA_BUILTIN_PROPERTY_INTRINSIC_PROPERTY, \
+    ECMA_PROPERTY_CONFIGURABLE_WRITABLE, \
+    magic_string_id \
+  },
+#define ACCESSOR_BUILTIN_FUNCTION(name, getter_builtin_id, setter_builtin_id, prop_attributes) \
+  { \
+    name, \
+    ECMA_BUILTIN_PROPERTY_ACCESSOR_BUILTIN_FUNCTION, \
+    prop_attributes, \
+    ECMA_ACCESSOR_READ_WRITE (getter_builtin_id, setter_builtin_id) \
+  },
+#endif /* ENABLED (JERRY_ES2015) */
 #define ACCESSOR_READ_WRITE(name, c_getter_name, c_setter_name, prop_attributes) \
   { \
     name, \
@@ -222,6 +254,11 @@ DISPATCH_ROUTINE_ROUTINE_NAME (uint16_t builtin_routine_id, /**< built-in wide r
        { \
          return c_function_name (this_arg_value ROUTINE_ARG_LIST_ ## args_number); \
        }
+#define ROUTINE_WITH_FLAGS(name, c_function_name, args_number, length_prop_value, flags) \
+       case ECMA_ROUTINE_ ## name ## c_function_name: \
+       { \
+         return c_function_name (this_arg_value ROUTINE_ARG_LIST_ ## args_number); \
+       }
 #define ACCESSOR_READ_WRITE(name, c_getter_func_name, c_setter_func_name, prop_attributes) \
        case ECMA_ACCESSOR_ ## name ## c_getter_func_name: \
        { \

jerry-core/ecma/builtin-objects/ecma-builtin-intrinsic.c

@@ -0,0 +1,73 @@
+/* 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 "ecma-builtins.h"
+#include "ecma-array-object.h"
+#include "ecma-gc.h"
+
+#if ENABLED (JERRY_ES2015)
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-intrinsic.inc.h"
+#define BUILTIN_UNDERSCORED_ID intrinsic
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup intrinsic ECMA Intrinsic object built-in
+ * @{
+ */
+
+/**
+ * The %ArrayProto_values% intrinsic routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.4.4.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_intrinsic_array_prototype_values (ecma_value_t this_value) /**< this argument */
+{
+  ecma_value_t this_obj = ecma_op_to_object (this_value);
+
+  if (ECMA_IS_VALUE_ERROR (this_obj))
+  {
+    return this_obj;
+  }
+
+  ecma_object_t *this_obj_p = ecma_get_object_from_value (this_obj);
+
+  ecma_value_t ret_value = ecma_op_create_array_iterator (this_obj_p, ECMA_ITERATOR_VALUES);
+
+  ecma_deref_object (this_obj_p);
+
+  return ret_value;
+} /* ecma_builtin_intrinsic_array_prototype_values */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-intrinsic.inc.h

@@ -0,0 +1,71 @@
+/* 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.
+ */
+
+/*
+ * Intrinsic built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if ENABLED (JERRY_ES2015)
+
+/* ECMA-262 v6, 19.4.2.2 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_HAS_INSTANCE,
+              LIT_MAGIC_STRING_HAS_INSTANCE)
+
+/* ECMA-262 v6, 19.4.2.3 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_IS_CONCAT_SPREADABLE,
+              LIT_MAGIC_STRING_IS_CONCAT_SPREADABLE)
+
+/* ECMA-262 v6, 19.4.2.4 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_ITERATOR,
+              LIT_MAGIC_STRING_ITERATOR)
+
+/* ECMA-262 v6, 19.4.2.6 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_MATCH,
+              LIT_MAGIC_STRING_MATCH)
+
+/* ECMA-262 v6, 19.4.2.8 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_REPLACE,
+              LIT_MAGIC_STRING_REPLACE)
+
+/* ECMA-262 v6, 19.4.2.9 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_SEARCH,
+              LIT_MAGIC_STRING_SEARCH)
+
+/* ECMA-262 v6, 19.4.2.10 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_SPECIES,
+              LIT_MAGIC_STRING_SPECIES)
+
+/* ECMA-262 v6, 19.4.2.11 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_SPLIT,
+              LIT_MAGIC_STRING_SPLIT)
+
+/* ECMA-262 v6, 19.4.2.12 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_TO_PRIMITIVE,
+              LIT_MAGIC_STRING_TO_PRIMITIVE)
+
+/* ECMA-262 v6, 19.4.2.13 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
+              LIT_MAGIC_STRING_TO_STRING_TAG)
+
+/* ECMA-262 v6, 19.4.2.14 */
+SYMBOL_VALUE (LIT_GLOBAL_SYMBOL_UNSCOPABLES,
+              LIT_MAGIC_STRING_UNSCOPABLES)
+
+ROUTINE (LIT_INTERNAL_MAGIC_STRING_ARRAY_PROTOTYPE_VALUES, ecma_builtin_intrinsic_array_prototype_values, 0, 0)
+
+#endif /* ENABLED (JERRY_ES2015) */
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-iterator-prototype.c

@@ -17,7 +17,7 @@
 #include "ecma-builtins.h"
 #include "ecma-iterator-object.h"
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
 
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"
@@ -60,4 +60,4 @@ ecma_builtin_iterator_prototype_object_iterator (ecma_value_t this_val) /**< thi
  * @}
  */
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-iterator-prototype.inc.h

@@ -19,12 +19,12 @@
 
 #include "ecma-builtin-helpers-macro-defines.inc.h"
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
 ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ecma_builtin_iterator_prototype_object_iterator, 0, 0)
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-json.c

@@ -571,13 +571,12 @@ ecma_builtin_json_parse_value (ecma_json_token_t *token_p) /**< token argument *
           break;
         }
 
-        ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 (length);
-        ecma_value_t completion = ecma_builtin_helper_def_prop (array_p,
-                                                                index_str_p,
-                                                                value,
-                                                                ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
+        ecma_value_t completion;
+        completion = ecma_builtin_helper_def_prop_by_index (array_p,
+                                                            length,
+                                                            value,
+                                                            ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
         JERRY_ASSERT (ecma_is_value_true (completion));
-        ecma_deref_ecma_string (index_str_p);
         ecma_free_value (value);
 
         ecma_builtin_json_parse_next_token (token_p, false);
@@ -738,15 +737,13 @@ ecma_builtin_json_parse (ecma_value_t this_arg, /**< 'this' argument */
 {
   JERRY_UNUSED (this_arg);
 
-  ecma_value_t text_value = ecma_op_to_string (arg1);
+  ecma_string_t *text_string_p = ecma_op_to_string (arg1);
 
-  if (ECMA_IS_VALUE_ERROR (text_value))
+  if (JERRY_UNLIKELY (text_string_p == NULL))
   {
-    return text_value;
+    return ECMA_VALUE_ERROR;
   }
 
-  ecma_string_t *text_string_p = ecma_get_string_from_value (text_value);
-
   ECMA_STRING_TO_UTF8_STRING (text_string_p, str_start_p, string_size);
   ecma_value_t result = ecma_builtin_json_parse_buffer (str_start_p, string_size);
   ECMA_FINALIZE_UTF8_STRING (str_start_p, string_size);
@@ -1176,7 +1173,8 @@ ecma_builtin_json_serialize_property (ecma_json_stringify_context_t *context_p,
     /* 5.b */
     else if (class_name == LIT_MAGIC_STRING_STRING_UL)
     {
-      result = ecma_op_to_string (value);
+      ecma_string_t *str_p = ecma_op_to_string (value);
+      result = ecma_make_string_value (str_p);
     }
     /* 5.c */
     else if (class_name == LIT_MAGIC_STRING_BOOLEAN_UL)
@@ -1236,9 +1234,8 @@ ecma_builtin_json_serialize_property (ecma_json_stringify_context_t *context_p,
     /* 10.a */
     if (!ecma_number_is_nan (num_value) && !ecma_number_is_infinity (num_value))
     {
-      ecma_value_t result_value = ecma_op_to_string (value);
-      JERRY_ASSERT (ecma_is_value_string (result_value));
-      ecma_string_t *result_string_p = ecma_get_string_from_value (result_value);
+      ecma_string_t *result_string_p = ecma_op_to_string (value);
+      JERRY_ASSERT (result_string_p != NULL);
 
       ecma_stringbuilder_append (&context_p->result_builder, result_string_p);
       ecma_deref_ecma_string (result_string_p);
@@ -1257,11 +1254,10 @@ ecma_builtin_json_serialize_property (ecma_json_stringify_context_t *context_p,
   if (ecma_is_value_object (value) && !ecma_op_is_callable (value))
   {
     ecma_object_t *obj_p = ecma_get_object_from_value (value);
-    lit_magic_string_id_t class_name = ecma_object_get_class_name (obj_p);
 
     ecma_value_t ret_value;
     /* 10.a */
-    if (class_name == LIT_MAGIC_STRING_ARRAY_UL)
+    if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY)
     {
       ret_value = ecma_builtin_json_serialize_array (context_p, obj_p);
     }
@@ -1375,7 +1371,7 @@ ecma_builtin_json_stringify (ecma_value_t this_arg, /**< 'this' argument */
       context.replacer_function_p = obj_p;
     }
     /* 4.b */
-    else if (ecma_object_get_class_name (obj_p) == LIT_MAGIC_STRING_ARRAY_UL)
+    else if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY)
     {
       ecma_extended_object_t *array_object_p = (ecma_extended_object_t *) obj_p;
       uint32_t array_length = array_object_p->u.array.length;
@@ -1384,9 +1380,7 @@ ecma_builtin_json_stringify (ecma_value_t this_arg, /**< 'this' argument */
       /* 4.b.iii.5 */
       while (index < array_length)
       {
-        ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 (index);
-        ecma_value_t value = ecma_op_object_get (obj_p, index_str_p);
-        ecma_deref_ecma_string (index_str_p);
+        ecma_value_t value = ecma_op_object_get_by_uint32_index (obj_p, index);
 
         if (ECMA_IS_VALUE_ERROR (value))
         {
@@ -1406,25 +1400,29 @@ ecma_builtin_json_stringify (ecma_value_t this_arg, /**< 'this' argument */
         /* 4.b.iii.5.e */
         else if (ecma_is_value_number (value))
         {
-          ecma_value_t number_str_value = ecma_op_to_string (value);
-          JERRY_ASSERT (ecma_is_value_string (number_str_value));
-          item = number_str_value;
+          ecma_string_t *number_str_p = ecma_op_to_string (value);
+          JERRY_ASSERT (number_str_p != NULL);
+          item = ecma_make_string_value (number_str_p);
         }
         /* 4.b.iii.5.f */
-        else if (ecma_is_value_object (value)
-                 && (ecma_object_get_class_name (ecma_get_object_from_value (value)) == LIT_MAGIC_STRING_NUMBER_UL
-                     || ecma_object_get_class_name (ecma_get_object_from_value (value)) == LIT_MAGIC_STRING_STRING_UL))
+        else if (ecma_is_value_object (value))
         {
-          ecma_value_t str_val = ecma_op_to_string (value);
+          ecma_object_t *value_obj_p = ecma_get_object_from_value (value);
+          lit_magic_string_id_t class_id = ecma_object_get_class_name (value_obj_p);
 
-          if (ECMA_IS_VALUE_ERROR (str_val))
+          if (class_id == LIT_MAGIC_STRING_NUMBER_UL || class_id == LIT_MAGIC_STRING_STRING_UL)
           {
-            ecma_collection_free (context.property_list_p);
-            ecma_free_value (value);
-            return str_val;
-          }
+            ecma_string_t *str_p = ecma_op_to_string (value);
 
-          item = str_val;
+            if (JERRY_UNLIKELY (str_p == NULL))
+            {
+              ecma_collection_free (context.property_list_p);
+              ecma_free_value (value);
+              return ECMA_VALUE_ERROR;
+            }
+
+            item = ecma_make_string_value (str_p);
+          }
         }
 
         ecma_free_value (value);
@@ -1474,15 +1472,15 @@ ecma_builtin_json_stringify (ecma_value_t this_arg, /**< 'this' argument */
     /* 5.b */
     else if (class_name == LIT_MAGIC_STRING_STRING_UL)
     {
-      ecma_value_t value = ecma_op_to_string (arg3);
+      ecma_string_t *value_str_p = ecma_op_to_string (arg3);
 
-      if (ECMA_IS_VALUE_ERROR (value))
+      if (JERRY_UNLIKELY (value_str_p == NULL))
       {
         ecma_collection_free (context.property_list_p);
-        return value;
+        return ECMA_VALUE_ERROR;
       }
 
-      space = value;
+      space = ecma_make_string_value (value_str_p);
     }
     else
     {
@@ -1497,9 +1495,10 @@ ecma_builtin_json_stringify (ecma_value_t this_arg, /**< 'this' argument */
   /* 6. */
   if (ecma_is_value_number (space))
   {
-    ecma_number_t number = ecma_get_number_from_value (space);
     /* 6.a */
-    int32_t num_of_spaces = ecma_number_to_int32 (number);
+    ecma_number_t num_of_spaces;
+    ecma_op_to_integer (space, &num_of_spaces);
+
     num_of_spaces = JERRY_MIN (10, num_of_spaces);
 
     /* 6.b */

jerry-core/ecma/builtin-objects/ecma-builtin-json.inc.h

@@ -21,12 +21,12 @@
 
 #if ENABLED (JERRY_BUILTIN_JSON)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 24.3.3 */
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_JSON_U,
               ECMA_PROPERTY_FLAG_CONFIGURABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */

jerry-core/ecma/builtin-objects/ecma-builtin-map-iterator-prototype.c

@@ -19,10 +19,6 @@
 
 #if ENABLED (JERRY_ES2015_BUILTIN_MAP)
 
-#if !ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
-#error "Map iterator builtin requires ES2015 iterator builtin"
-#endif /* !ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
-
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"
 

jerry-core/ecma/builtin-objects/ecma-builtin-map-prototype.c

@@ -96,7 +96,7 @@ static ecma_value_t
 ecma_builtin_map_prototype_object_get (ecma_value_t this_arg, /**< this argument */
                                        ecma_value_t key_arg) /**< key argument */
 {
-  return ecma_op_container_get (this_arg, key_arg);
+  return ecma_op_container_get (this_arg, key_arg, LIT_MAGIC_STRING_MAP_UL);
 } /* ecma_builtin_map_prototype_object_get */
 
 /**
@@ -147,7 +147,8 @@ ecma_builtin_map_prototype_object_size_getter (ecma_value_t this_arg) /**< this
   return ecma_op_container_size (this_arg, LIT_MAGIC_STRING_MAP_UL);
 } /* ecma_builtin_map_prototype_object_size_getter */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * The Map.prototype object's 'entries' routine
  *
@@ -205,7 +206,7 @@ ecma_builtin_map_prototype_object_values (ecma_value_t this_arg) /**< this argum
                                             ECMA_PSEUDO_MAP_ITERATOR);
 } /* ecma_builtin_map_prototype_object_values */
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-map-prototype.inc.h

@@ -29,12 +29,12 @@ OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR,
               ECMA_BUILTIN_ID_MAP,
               ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 23.1.3.13 */
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_MAP_UL,
               ECMA_PROPERTY_FLAG_CONFIGURABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
@@ -44,12 +44,12 @@ ROUTINE (LIT_MAGIC_STRING_FOR_EACH_UL, ecma_builtin_map_prototype_object_foreach
 ROUTINE (LIT_MAGIC_STRING_GET, ecma_builtin_map_prototype_object_get, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_HAS, ecma_builtin_map_prototype_object_has, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_SET, ecma_builtin_map_prototype_object_set, 2, 2)
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_ENTRIES, ecma_builtin_map_prototype_object_entries, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_VALUES, ecma_builtin_map_prototype_object_values, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_KEYS, ecma_builtin_map_prototype_object_keys, 0, 0)
-ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ecma_builtin_map_prototype_object_values, 0, 0)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ecma_builtin_map_prototype_object_entries, 0, 0)
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* ECMA-262 v6, 23.1.3.10 */
 ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_SIZE,

jerry-core/ecma/builtin-objects/ecma-builtin-map.c

@@ -65,6 +65,18 @@ ecma_builtin_map_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
                                    ECMA_BUILTIN_ID_MAP_PROTOTYPE);
 } /* ecma_builtin_map_dispatch_construct */
 
+/**
+ * 23.1.2.2 get Map [ @@species ] accessor
+ *
+ * @return ecma_value
+ *         returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_builtin_map_species_get (ecma_value_t this_value) /**< This Value */
+{
+  return ecma_copy_value (this_value);
+} /* ecma_builtin_map_species_get */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-map.inc.h

@@ -42,6 +42,11 @@ OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
               ECMA_BUILTIN_ID_MAP_PROTOTYPE,
               ECMA_PROPERTY_FIXED)
 
+/* ECMA-262 v6, 23.1.2.2 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES,
+                    ecma_builtin_map_species_get,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_MAP) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-math.c

@@ -55,10 +55,10 @@ enum
   ECMA_MATH_OBJECT_EXP, /* ECMA-262 v5, 15.8.2.8 */
   ECMA_MATH_OBJECT_FLOOR, /* ECMA-262 v5, 15.8.2.9 */
   ECMA_MATH_OBJECT_LOG, /* ECMA-262 v5, 15.8.2.10 */
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
   ECMA_MATH_OBJECT_TRUNC, /* ECMA-262 v6, 20.2.2.35  */
   ECMA_MATH_OBJECT_SIGN, /* ECMA-262 v6, 20.2.2.29 */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+#endif /* ENABLED (JERRY_ES2015) */
   ECMA_MATH_OBJECT_ROUND, /* ECMA-262 v5, 15.8.2.15 */
   ECMA_MATH_OBJECT_SIN, /* ECMA-262 v5, 15.8.2.16 */
   ECMA_MATH_OBJECT_SQRT, /* ECMA-262 v5, 15.8.2.17 */
@@ -103,6 +103,7 @@ ecma_builtin_math_object_max_min (bool is_max, /**< 'max' or 'min' operation */
                                   ecma_length_t args_number) /**< number of arguments */
 {
   ecma_number_t result_num = ecma_number_make_infinity (is_max);
+  bool nan_found = false;
 
   while (args_number > 0)
   {
@@ -126,10 +127,13 @@ ecma_builtin_math_object_max_min (bool is_max, /**< 'max' or 'min' operation */
       ecma_fast_free_value (value);
     }
 
-    if (JERRY_UNLIKELY (ecma_number_is_nan (arg_num)))
+    arg++;
+    args_number--;
+
+    if (JERRY_UNLIKELY (nan_found || ecma_number_is_nan (arg_num)))
     {
-      result_num = arg_num;
-      break;
+      nan_found = true;
+      continue;
     }
 
     if (ecma_number_is_zero (arg_num)
@@ -149,15 +153,18 @@ ecma_builtin_math_object_max_min (bool is_max, /**< 'max' or 'min' operation */
         result_num = arg_num;
       }
     }
+  }
 
-    arg++;
-    args_number--;
+  if (JERRY_UNLIKELY (nan_found))
+  {
+    result_num = ecma_number_make_nan ();
   }
 
   return ecma_make_number_value (result_num);
 } /* ecma_builtin_math_object_max_min */
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * The Math object's 'trunc' routine
  *
@@ -176,12 +183,12 @@ ecma_builtin_math_object_trunc (ecma_number_t arg)
 
   if ((arg > 0) && (arg < 1))
   {
-    return (ecma_number_t) 0;
+    return (ecma_number_t) 0.0;
   }
 
   if ((arg < 0) && (arg > -1))
   {
-    return (ecma_number_t) -0;
+    return (ecma_number_t) -0.0;
   }
 
   return (ecma_number_t) arg - fmod (arg, 1);
@@ -210,7 +217,8 @@ ecma_builtin_math_object_sign (ecma_number_t arg)
 
   return (ecma_number_t) 1.0;
 } /* ecma_builtin_math_object_sign */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * The Math object's 'random' routine.
@@ -341,7 +349,7 @@ ecma_builtin_math_dispatch_routine (uint16_t builtin_routine_id, /**< built-in w
         x = DOUBLE_TO_ECMA_NUMBER_T (log (x));
         break;
       }
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
       case ECMA_MATH_OBJECT_TRUNC:
       {
         x = ecma_builtin_math_object_trunc (x);
@@ -352,12 +360,13 @@ ecma_builtin_math_dispatch_routine (uint16_t builtin_routine_id, /**< built-in w
         x = ecma_builtin_math_object_sign (x);
         break;
       }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+#endif /* ENABLED (JERRY_ES2015) */
       case ECMA_MATH_OBJECT_ROUND:
       {
         if (ecma_number_is_nan (x)
             || ecma_number_is_zero (x)
-            || ecma_number_is_infinity (x))
+            || ecma_number_is_infinity (x)
+            || fmod (x, 1.0) == 0)
         {
           /* Do nothing. */
         }
@@ -435,7 +444,6 @@ ecma_builtin_math_dispatch_routine (uint16_t builtin_routine_id, /**< built-in w
                                              arguments_number);
   }
 
-
   JERRY_ASSERT (builtin_routine_id == ECMA_MATH_OBJECT_RANDOM);
 
   return ecma_builtin_math_object_random ();

jerry-core/ecma/builtin-objects/ecma-builtin-math.inc.h

@@ -64,12 +64,12 @@ NUMBER_VALUE (LIT_MAGIC_STRING_SQRT2_U,
               ECMA_BUILTIN_NUMBER_SQRT2,
               ECMA_PROPERTY_FIXED)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 20.2.1.9 */
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_MATH_UL,
               ECMA_PROPERTY_FLAG_CONFIGURABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
@@ -91,10 +91,10 @@ ROUTINE (LIT_MAGIC_STRING_ROUND, ECMA_MATH_OBJECT_ROUND, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_SIN, ECMA_MATH_OBJECT_SIN, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_SQRT, ECMA_MATH_OBJECT_SQRT, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_TAN, ECMA_MATH_OBJECT_TAN, 1, 1)
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_SIGN, ECMA_MATH_OBJECT_SIGN, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_TRUNC, ECMA_MATH_OBJECT_TRUNC, 1, 1)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #endif /* ENABLED (JERRY_BUILTIN_MATH) */
 

jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c

@@ -249,16 +249,6 @@ ecma_builtin_number_prototype_object_to_string (ecma_number_t this_arg_number, /
                                                 const ecma_value_t *arguments_list_p, /**< arguments list */
                                                 ecma_length_t arguments_list_len) /**< number of arguments */
 {
-
-  if (arguments_list_len == 0
-      || ecma_number_is_nan (this_arg_number)
-      || ecma_number_is_infinity (this_arg_number)
-      || ecma_number_is_zero (this_arg_number)
-      || (arguments_list_len > 0 && ecma_is_value_undefined (arguments_list_p[0])))
-  {
-    ecma_string_t *ret_str_p = ecma_new_ecma_string_from_number (this_arg_number);
-    return ecma_make_string_value (ret_str_p);
-  }
   static const lit_utf8_byte_t digit_chars[36] =
   {
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
@@ -267,27 +257,33 @@ ecma_builtin_number_prototype_object_to_string (ecma_number_t this_arg_number, /
     'u', 'v', 'w', 'x', 'y', 'z'
   };
 
-  ecma_number_t arg_num;
-  ecma_value_t radix_num = ecma_get_number (arguments_list_p[0], &arg_num);
-
-  if (!ecma_is_value_empty (radix_num))
+  uint32_t radix = 10;
+  if (arguments_list_len > 0 && !ecma_is_value_undefined (arguments_list_p[0]))
   {
-    return radix_num;
+    ecma_number_t arg_num;
+
+    if (ECMA_IS_VALUE_ERROR (ecma_op_to_integer (arguments_list_p[0], &arg_num)))
+    {
+      return ECMA_VALUE_ERROR;
+    }
+
+    radix = ecma_number_to_uint32 (arg_num);
+
+    if (radix < 2 || radix > 36)
+    {
+      return ecma_raise_range_error (ECMA_ERR_MSG ("Radix must be between 2 and 36."));
+    }
   }
 
-  uint32_t radix = ecma_number_to_uint32 (arg_num);
-
-  if (radix < 2 || radix > 36)
-  {
-    return ecma_raise_range_error (ECMA_ERR_MSG ("Radix must be between 2 and 36."));
-  }
-
-  if (radix == 10)
+  if (ecma_number_is_nan (this_arg_number)
+      || ecma_number_is_infinity (this_arg_number)
+      || ecma_number_is_zero (this_arg_number)
+      || radix == 10)
   {
     ecma_string_t *ret_str_p = ecma_new_ecma_string_from_number (this_arg_number);
-
     return ecma_make_string_value (ret_str_p);
   }
+
   int buff_size = 0;
 
   bool is_number_negative = false;
@@ -373,14 +369,14 @@ ecma_builtin_number_prototype_object_to_string (ecma_number_t this_arg_number, /
   {
     for (int i = 0; i < magnitude; i++)
     {
-      this_arg_number /= (ecma_number_t) radix;
+      this_arg_number /= radix;
     }
   }
   else if (exponent < 0)
   {
     for (int i = 0; i < magnitude; i++)
     {
-      this_arg_number *= (ecma_number_t) radix;
+      this_arg_number *= radix;
     }
   }
 
@@ -443,7 +439,7 @@ ecma_builtin_number_prototype_object_to_string (ecma_number_t this_arg_number, /
   /* Calculate digits for fractional part. */
   while (buff_index < required_digits)
   {
-    fraction *= (ecma_number_t) radix;
+    fraction *= radix;
     lit_utf8_byte_t digit = (lit_utf8_byte_t) floor (fraction);
 
     buff[buff_index++] = digit;
@@ -596,9 +592,9 @@ ecma_builtin_number_prepare_conversion (ecma_number_t *this_num_p, /**< [out] th
   JERRY_ASSERT (mode < NUMBER_ROUTINE__COUNT);
 
   ecma_number_t arg_num;
-  arg_1 = ecma_get_number (arg_1, &arg_num);
+  arg_1 = ecma_op_to_integer (arg_1, &arg_num);
 
-  if (!ecma_is_value_empty (arg_1))
+  if (ECMA_IS_VALUE_ERROR (arg_1))
   {
     return arg_1;
   }

jerry-core/ecma/builtin-objects/ecma-builtin-number.c

@@ -93,7 +93,8 @@ ecma_builtin_number_dispatch_construct (const ecma_value_t *arguments_list_p, /*
   }
 } /* ecma_builtin_number_dispatch_construct */
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * The Number object 'isFinite' routine
  *
@@ -173,7 +174,8 @@ ecma_builtin_number_object_is_integer (ecma_value_t this_arg, /**< this argument
     return ECMA_VALUE_FALSE;
   }
 
-  ecma_number_t int_num = ecma_number_trunc (num);
+  ecma_number_t int_num;
+  ecma_op_to_integer (arg, &int_num);
 
   if (int_num != num)
   {
@@ -219,7 +221,8 @@ ecma_builtin_number_object_is_safe_integer (ecma_value_t this_arg, /**< this arg
 
   return ECMA_VALUE_FALSE;
 } /* ecma_builtin_number_object_is_safe_integer */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-number.inc.h

@@ -54,6 +54,25 @@ NUMBER_VALUE (LIT_MAGIC_STRING_NEGATIVE_INFINITY_U,
               ECMA_BUILTIN_NUMBER_NEGATIVE_INFINITY,
               ECMA_PROPERTY_FIXED)
 
+#if ENABLED (JERRY_ES2015)
+
+/* ECMA-262 v6, 20.1.2.1 */
+NUMBER_VALUE (LIT_MAGIC_STRING_EPSILON_U,
+              ECMA_BUILTIN_NUMBER_EPSILON,
+              ECMA_PROPERTY_FIXED)
+
+/* ECMA-262 v6, 20.1.2.6 */
+NUMBER_VALUE (LIT_MAGIC_STRING_MAX_SAFE_INTEGER_U,
+              ECMA_BUILTIN_NUMBER_MAX_SAFE_INTEGER,
+              ECMA_PROPERTY_FIXED)
+
+/* ECMA-262 v6, 20.1.2.8 */
+NUMBER_VALUE (LIT_MAGIC_STRING_MIN_SAFE_INTEGER_U,
+              ECMA_BUILTIN_NUMBER_MIN_SAFE_INTEGER,
+              ECMA_PROPERTY_FIXED)
+
+#endif /* ENABLED (JERRY_ES2015) */
+
 /* Object properties:
  *  (property name, object pointer getter) */
 
@@ -66,10 +85,10 @@ OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_IS_FINITE, ecma_builtin_number_object_is_finite, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_IS_NAN, ecma_builtin_number_object_is_nan, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_IS_INTEGER, ecma_builtin_number_object_is_integer, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_IS_SAFE_INTEGER, ecma_builtin_number_object_is_safe_integer, 1, 1)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+#endif /* ENABLED (JERRY_ES2015) */
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-object-prototype.c

@@ -50,7 +50,6 @@ enum
   ECMA_OBJECT_PROTOTYPE_PROPERTY_IS_ENUMERABLE,
 };
 
-
 #define BUILTIN_INC_HEADER_NAME "ecma-builtin-object-prototype.inc.h"
 #define BUILTIN_UNDERSCORED_ID object_prototype
 #include "ecma-builtin-internal-routines-template.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-object.c

@@ -24,6 +24,7 @@
 #include "ecma-objects.h"
 #include "ecma-objects-general.h"
 #include "jrt.h"
+#include "ecma-builtin-object.h"
 
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"
@@ -39,22 +40,32 @@
 enum
 {
   ECMA_OBJECT_ROUTINE_START = ECMA_BUILTIN_ID__COUNT - 1,
-  ECMA_OBJECT_ROUTINE_DEFINE_PROPERTY,
-  ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_DESCRIPTOR,
-  ECMA_OBJECT_ROUTINE_DEFINE_PROPERTIES,
+
   ECMA_OBJECT_ROUTINE_CREATE,
-  ECMA_OBJECT_ROUTINE_SEAL,
-  ECMA_OBJECT_ROUTINE_FREEZE,
-  ECMA_OBJECT_ROUTINE_PREVENT_EXTENSIONS,
-  ECMA_OBJECT_ROUTINE_IS_SEALED,
-  ECMA_OBJECT_ROUTINE_IS_FROZEN,
-  ECMA_OBJECT_ROUTINE_IS_EXTENSIBLE,
+  ECMA_OBJECT_ROUTINE_IS,
+  ECMA_OBJECT_ROUTINE_SET_PROTOTYPE_OF,
+
+  /* These should be in this order. */
+  ECMA_OBJECT_ROUTINE_DEFINE_PROPERTY,
+  ECMA_OBJECT_ROUTINE_DEFINE_PROPERTIES,
+
+  /* These should be in this order. */
+  ECMA_OBJECT_ROUTINE_ASSIGN,
+  ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_DESCRIPTOR,
   ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_NAMES,
   ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_SYMBOLS,
-  ECMA_OBJECT_ROUTINE_KEYS,
   ECMA_OBJECT_ROUTINE_GET_PROTOTYPE_OF,
-  ECMA_OBJECT_ROUTINE_SET_PROTOTYPE_OF,
-  ECMA_OBJECT_ROUTINE_ASSIGN,
+  ECMA_OBJECT_ROUTINE_KEYS,
+
+  /* These should be in this order. */
+  ECMA_OBJECT_ROUTINE_FREEZE,
+  ECMA_OBJECT_ROUTINE_PREVENT_EXTENSIONS,
+  ECMA_OBJECT_ROUTINE_SEAL,
+
+  /* These should be in this order. */
+  ECMA_OBJECT_ROUTINE_IS_EXTENSIBLE,
+  ECMA_OBJECT_ROUTINE_IS_FROZEN,
+  ECMA_OBJECT_ROUTINE_IS_SEALED,
 };
 
 #define BUILTIN_INC_HEADER_NAME "ecma-builtin-object.inc.h"
@@ -122,51 +133,23 @@ ecma_builtin_object_dispatch_construct (const ecma_value_t *arguments_list_p, /*
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-static ecma_value_t
-ecma_builtin_object_object_get_prototype_of (ecma_value_t arg) /**< routine's argument */
+ecma_value_t
+ecma_builtin_object_object_get_prototype_of (ecma_object_t *obj_p) /**< routine's argument */
 {
-  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
-  bool was_object = ecma_is_value_object (arg);
-
-  /* 1. */
-  if (!was_object)
-  {
-#if ENABLED (JERRY_ES2015_BUILTIN)
-    arg = ecma_op_to_object (arg);
-    if (ECMA_IS_VALUE_ERROR (arg))
-    {
-      return arg;
-    }
-#else /* !ENABLED (JERRY_ES2015_BUILTIN) */
-    return ecma_raise_type_error (ECMA_ERR_MSG ("Argument is not an object."));
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
-  }
-  /* 2. */
-  ecma_object_t *obj_p = ecma_get_object_from_value (arg);
   jmem_cpointer_t prototype_cp = obj_p->u2.prototype_cp;
 
   if (prototype_cp != JMEM_CP_NULL)
   {
     ecma_object_t *prototype_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t, prototype_cp);
-    ret_value = ecma_make_object_value (prototype_p);
     ecma_ref_object (prototype_p);
-  }
-  else
-  {
-    ret_value = ECMA_VALUE_NULL;
+    return ecma_make_object_value (prototype_p);
   }
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
-  if (!was_object)
-  {
-    ecma_deref_object (obj_p);
-  }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
-
-  return ret_value;
+  return ECMA_VALUE_NULL;
 } /* ecma_builtin_object_object_get_prototype_of */
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * [[SetPrototypeOf]]
  *
@@ -197,7 +180,6 @@ ecma_set_prototype_of (ecma_value_t o_value, /**< O */
     ECMA_SET_NON_NULL_POINTER (v_cp, ecma_get_object_from_value (v_value));
   }
 
-
   /* 3., 4. */
   if (v_cp == o_p->u2.prototype_cp)
   {
@@ -247,7 +229,7 @@ ecma_set_prototype_of (ecma_value_t o_value, /**< O */
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-static ecma_value_t
+ecma_value_t
 ecma_builtin_object_object_set_prototype_of (ecma_value_t arg1, /**< routine's first argument */
                                              ecma_value_t arg2) /**< routine's second argument */
 {
@@ -275,7 +257,8 @@ ecma_builtin_object_object_set_prototype_of (ecma_value_t arg1, /**< routine's f
   /* 5-8. */
   return ecma_set_prototype_of (arg1, arg2);
 } /* ecma_builtin_object_object_set_prototype_of */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * The Object object's 'getOwnPropertyNames' routine
@@ -292,7 +275,8 @@ ecma_builtin_object_object_get_own_property_names (ecma_object_t *obj_p) /**< ro
   return ecma_builtin_helper_object_get_properties (obj_p, ECMA_LIST_NO_OPTS);
 } /* ecma_builtin_object_object_get_own_property_names */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * The Object object's 'getOwnPropertySymbols' routine
  *
@@ -305,9 +289,10 @@ ecma_builtin_object_object_get_own_property_names (ecma_object_t *obj_p) /**< ro
 static ecma_value_t
 ecma_builtin_object_object_get_own_property_symbols (ecma_object_t *obj_p) /**< routine's argument */
 {
-  return ecma_builtin_helper_object_get_properties (obj_p, ECMA_LIST_SYMBOLS);
+  return ecma_builtin_helper_object_get_properties (obj_p, ECMA_LIST_SYMBOLS_ONLY);
 } /* ecma_builtin_object_object_get_own_property_symbols */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * The Object object's 'seal' routine
@@ -441,7 +426,7 @@ ecma_builtin_object_object_freeze (ecma_object_t *obj_p) /**< routine's argument
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-static ecma_value_t
+ecma_value_t
 ecma_builtin_object_object_prevent_extensions (ecma_object_t *obj_p) /**< routine's argument */
 {
   ecma_set_object_extensible (obj_p, false);
@@ -521,7 +506,7 @@ ecma_builtin_object_frozen_or_sealed_helper (ecma_object_t *obj_p, /**< routine'
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-static ecma_value_t
+ecma_value_t
 ecma_builtin_object_object_is_extensible (ecma_object_t *obj_p) /**< routine's argument */
 {
   return ecma_make_boolean_value (ecma_get_object_extensible (obj_p));
@@ -551,7 +536,7 @@ ecma_builtin_object_object_keys (ecma_object_t *obj_p) /**< routine's argument *
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-static ecma_value_t
+ecma_value_t
 ecma_builtin_object_object_get_own_property_descriptor (ecma_object_t *obj_p, /**< routine's first argument */
                                                         ecma_string_t *name_str_p) /**< routine's second argument */
 {
@@ -724,7 +709,7 @@ ecma_builtin_object_object_create (ecma_value_t arg1, /**< routine's first argum
  * @return ecma value
  *         Returned value must be freed with ecma_free_value.
  */
-static ecma_value_t
+ecma_value_t
 ecma_builtin_object_object_define_property (ecma_object_t *obj_p, /**< routine's first argument */
                                             ecma_string_t *name_str_p, /**< routine's second argument */
                                             ecma_value_t arg3) /**< routine's third argument */
@@ -758,8 +743,8 @@ ecma_builtin_object_object_define_property (ecma_object_t *obj_p, /**< routine's
   return ecma_make_object_value (obj_p);
 } /* ecma_builtin_object_object_define_property */
 
+#if ENABLED (JERRY_ES2015)
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
 /**
  * The Object object's 'assign' routine
  *
@@ -770,31 +755,14 @@ ecma_builtin_object_object_define_property (ecma_object_t *obj_p, /**< routine's
  *         Returned value must be freed with ecma_free_value.
  */
 static ecma_value_t
-ecma_builtin_object_object_assign (const ecma_value_t arguments_list_p[], /**< arguments list */
+ecma_builtin_object_object_assign (ecma_object_t *target_p, /**< target object */
+                                   const ecma_value_t arguments_list_p[], /**< arguments list */
                                    ecma_length_t arguments_list_len) /**< number of arguments */
 {
-  ecma_value_t target = arguments_list_len > 0 ? arguments_list_p[0] : ECMA_VALUE_UNDEFINED;
-
-  /* 1. */
-  ecma_value_t to_value = ecma_op_to_object (target);
-
-  if (ECMA_IS_VALUE_ERROR (to_value))
-  {
-    return to_value;
-  }
-
-  ecma_object_t *to_obj_p = ecma_get_object_from_value (to_value);
-
-  /* 2. */
-  if (arguments_list_len == 1)
-  {
-    return to_value;
-  }
-
   ecma_value_t ret_value = ECMA_VALUE_EMPTY;
 
   /* 4-5. */
-  for (uint32_t i = 1; i < arguments_list_len && ecma_is_value_empty (ret_value); i++)
+  for (uint32_t i = 0; i < arguments_list_len && ecma_is_value_empty (ret_value); i++)
   {
     ecma_value_t next_source = arguments_list_p[i];
 
@@ -812,15 +780,15 @@ ecma_builtin_object_object_assign (const ecma_value_t arguments_list_p[], /**< a
     ecma_object_t *from_obj_p = ecma_get_object_from_value (from_value);
 
     /* 5.b.iii */
-    /* TODO: extends this collection if symbols will be supported */
     ecma_collection_t *props_p = ecma_op_object_get_property_names (from_obj_p, ECMA_LIST_CONVERT_FAST_ARRAYS
-                                                                                | ECMA_LIST_ENUMERABLE);
+                                                                                | ECMA_LIST_ENUMERABLE
+                                                                                | ECMA_LIST_SYMBOLS);
 
     ecma_value_t *buffer_p = props_p->buffer_p;
 
     for (uint32_t j = 0; (j < props_p->item_count) && ecma_is_value_empty (ret_value); j++)
     {
-      ecma_string_t *property_name_p = ecma_get_string_from_value (buffer_p[j]);
+      ecma_string_t *property_name_p = ecma_get_prop_name_from_value (buffer_p[j]);
 
       /* 5.c.i-ii */
       ecma_property_descriptor_t prop_desc;
@@ -846,7 +814,7 @@ ecma_builtin_object_object_assign (const ecma_value_t arguments_list_p[], /**< a
         else
         {
           /* 5.c.iii.3 */
-          ecma_value_t status = ecma_op_object_put (to_obj_p, property_name_p, prop_value, true);
+          ecma_value_t status = ecma_op_object_put (target_p, property_name_p, prop_value, true);
 
           /* 5.c.iii.4 */
           if (ECMA_IS_VALUE_ERROR (status))
@@ -867,13 +835,30 @@ ecma_builtin_object_object_assign (const ecma_value_t arguments_list_p[], /**< a
   /* 6. */
   if (ecma_is_value_empty (ret_value))
   {
-    return to_value;
+    ecma_ref_object (target_p);
+    return ecma_make_object_value (target_p);
   }
 
-  ecma_deref_object (to_obj_p);
   return ret_value;
 } /* ecma_builtin_object_object_assign */
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+
+/**
+ * The Object object's 'is' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 19.1.2.10
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_object_object_is (ecma_value_t arg1, /**< routine's first argument */
+                               ecma_value_t arg2) /**< routine's second argument */
+{
+  return ecma_op_same_value (arg1, arg2) ? ECMA_VALUE_TRUE : ECMA_VALUE_FALSE;
+} /* ecma_builtin_object_object_is */
+
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * Dispatcher of the built-in's routines
@@ -903,103 +888,185 @@ ecma_builtin_object_dispatch_routine (uint16_t builtin_routine_id, /**< built-in
     {
       return ecma_builtin_object_object_create (arg1, arg2);
     }
-    case ECMA_OBJECT_ROUTINE_GET_PROTOTYPE_OF:
-    {
-      return ecma_builtin_object_object_get_prototype_of (arg1);
-    }
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
     case ECMA_OBJECT_ROUTINE_SET_PROTOTYPE_OF:
     {
       return ecma_builtin_object_object_set_prototype_of (arg1, arg2);
     }
-    case ECMA_OBJECT_ROUTINE_ASSIGN:
+    case ECMA_OBJECT_ROUTINE_IS:
     {
-      return ecma_builtin_object_object_assign (arguments_list_p, arguments_number);
+      return ecma_builtin_object_object_is (arg1, arg2);
     }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+#endif /* ENABLED (JERRY_ES2015) */
     default:
     {
       break;
     }
   }
 
+  ecma_object_t *obj_p;
+#if !ENABLED (JERRY_ES2015)
   if (!ecma_is_value_object (arg1))
   {
     return ecma_raise_type_error (ECMA_ERR_MSG ("Argument is not an object."));
   }
+#endif /* !ENABLED (JERRY_ES2015) */
 
-  ecma_object_t *obj_p = ecma_get_object_from_value (arg1);
-
-  if (builtin_routine_id <= ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_DESCRIPTOR)
+  if (builtin_routine_id <= ECMA_OBJECT_ROUTINE_DEFINE_PROPERTIES)
   {
-    ecma_string_t *prop_name_p = ecma_op_to_prop_name (arg2);
-
-    if (prop_name_p == NULL)
+#if ENABLED (JERRY_ES2015)
+    if (!ecma_is_value_object (arg1))
     {
-      return ECMA_VALUE_ERROR;
+      return ecma_raise_type_error (ECMA_ERR_MSG ("Argument is not an object."));
     }
+#endif /* ENABLED (JERRY_ES2015) */
 
-    ecma_value_t ret_value;
+    obj_p = ecma_get_object_from_value (arg1);
 
     if (builtin_routine_id == ECMA_OBJECT_ROUTINE_DEFINE_PROPERTY)
     {
-      ret_value = ecma_builtin_object_object_define_property (obj_p, prop_name_p, arguments_list_p[2]);
-    }
-    else
-    {
-      JERRY_ASSERT (builtin_routine_id == ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_DESCRIPTOR);
-      ret_value = ecma_builtin_object_object_get_own_property_descriptor (obj_p, prop_name_p);
+      ecma_string_t *prop_name_p = ecma_op_to_prop_name (arg2);
+
+      if (prop_name_p == NULL)
+      {
+        return ECMA_VALUE_ERROR;
+      }
+
+      ecma_value_t result = ecma_builtin_object_object_define_property (obj_p, prop_name_p, arguments_list_p[2]);
+
+      ecma_deref_ecma_string (prop_name_p);
+      return result;
     }
 
-    ecma_deref_ecma_string (prop_name_p);
-    return ret_value;
+    JERRY_ASSERT (builtin_routine_id == ECMA_OBJECT_ROUTINE_DEFINE_PROPERTIES);
+    return ecma_builtin_object_object_define_properties (obj_p, arg2);
   }
-
-  switch (builtin_routine_id)
+  else if (builtin_routine_id <= ECMA_OBJECT_ROUTINE_KEYS)
   {
-    case ECMA_OBJECT_ROUTINE_SEAL:
+#if ENABLED (JERRY_ES2015)
+    ecma_value_t object = ecma_op_to_object (arg1);
+    if (ECMA_IS_VALUE_ERROR (object))
     {
-      return ecma_builtin_object_object_seal (obj_p);
+      return object;
     }
-    case ECMA_OBJECT_ROUTINE_FREEZE:
+
+    obj_p = ecma_get_object_from_value (object);
+#else /* !ENABLED (JERRY_ES2015) */
+    obj_p = ecma_get_object_from_value (arg1);
+#endif /* ENABLED (JERRY_ES2015) */
+
+    ecma_value_t result;
+    switch (builtin_routine_id)
     {
-      return ecma_builtin_object_object_freeze (obj_p);
+      case ECMA_OBJECT_ROUTINE_GET_PROTOTYPE_OF:
+      {
+        result = ecma_builtin_object_object_get_prototype_of (obj_p);
+        break;
+      }
+      case ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_NAMES:
+      {
+        result = ecma_builtin_object_object_get_own_property_names (obj_p);
+        break;
+      }
+#if ENABLED (JERRY_ES2015)
+      case ECMA_OBJECT_ROUTINE_ASSIGN:
+      {
+        result = ecma_builtin_object_object_assign (obj_p, arguments_list_p + 1, arguments_number - 1);
+        break;
+      }
+      case ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_SYMBOLS:
+      {
+        result = ecma_builtin_object_object_get_own_property_symbols (obj_p);
+        break;
+      }
+#endif /* ENABLED (JERRY_ES2015) */
+      case ECMA_OBJECT_ROUTINE_KEYS:
+      {
+        result = ecma_builtin_object_object_keys (obj_p);
+        break;
+      }
+      case ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_DESCRIPTOR:
+      {
+        ecma_string_t *prop_name_p = ecma_op_to_prop_name (arg2);
+
+        if (prop_name_p == NULL)
+        {
+          result = ECMA_VALUE_ERROR;
+          break;
+        }
+
+        result = ecma_builtin_object_object_get_own_property_descriptor (obj_p, prop_name_p);
+        ecma_deref_ecma_string (prop_name_p);
+        break;
+      }
+      default:
+      {
+        JERRY_UNREACHABLE ();
+      }
     }
-    case ECMA_OBJECT_ROUTINE_PREVENT_EXTENSIONS:
+
+#if ENABLED (JERRY_ES2015)
+    ecma_deref_object (obj_p);
+#endif /* ENABLED (JERRY_ES2015) */
+    return result;
+  }
+  else if (builtin_routine_id <= ECMA_OBJECT_ROUTINE_SEAL)
+  {
+#if ENABLED (JERRY_ES2015)
+    if (!ecma_is_value_object (arg1))
     {
-      return ecma_builtin_object_object_prevent_extensions (obj_p);
+      return ecma_copy_value (arg1);
     }
-    case ECMA_OBJECT_ROUTINE_IS_SEALED:
-    case ECMA_OBJECT_ROUTINE_IS_FROZEN:
+#endif /* ENABLED (JERRY_ES2015) */
+
+    obj_p = ecma_get_object_from_value (arg1);
+    switch (builtin_routine_id)
     {
-      return ecma_builtin_object_frozen_or_sealed_helper (obj_p,
-                                                          builtin_routine_id);
+      case ECMA_OBJECT_ROUTINE_SEAL:
+      {
+        return ecma_builtin_object_object_seal (obj_p);
+      }
+      case ECMA_OBJECT_ROUTINE_FREEZE:
+      {
+        return ecma_builtin_object_object_freeze (obj_p);
+      }
+      case ECMA_OBJECT_ROUTINE_PREVENT_EXTENSIONS:
+      {
+        return ecma_builtin_object_object_prevent_extensions (obj_p);
+      }
+      default:
+      {
+        JERRY_UNREACHABLE ();
+      }
     }
-    case ECMA_OBJECT_ROUTINE_IS_EXTENSIBLE:
+  }
+  else
+  {
+    JERRY_ASSERT (builtin_routine_id <= ECMA_OBJECT_ROUTINE_IS_SEALED);
+#if ENABLED (JERRY_ES2015)
+    if (!ecma_is_value_object (arg1))
     {
-      return ecma_builtin_object_object_is_extensible (obj_p);
+      return ecma_make_boolean_value (builtin_routine_id != ECMA_OBJECT_ROUTINE_IS_EXTENSIBLE);
     }
-    case ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_NAMES:
+#endif /* ENABLED (JERRY_ES2015) */
+
+    obj_p = ecma_get_object_from_value (arg1);
+    switch (builtin_routine_id)
     {
-      return ecma_builtin_object_object_get_own_property_names (obj_p);
-    }
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
-    case ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_SYMBOLS:
-    {
-      return ecma_builtin_object_object_get_own_property_symbols (obj_p);
-    }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
-    case ECMA_OBJECT_ROUTINE_KEYS:
-    {
-      return ecma_builtin_object_object_keys (obj_p);
-    }
-    case ECMA_OBJECT_ROUTINE_DEFINE_PROPERTIES:
-    {
-      return ecma_builtin_object_object_define_properties (obj_p, arg2);
-    }
-    default:
-    {
-      JERRY_UNREACHABLE ();
+      case ECMA_OBJECT_ROUTINE_IS_SEALED:
+      case ECMA_OBJECT_ROUTINE_IS_FROZEN:
+      {
+        return ecma_builtin_object_frozen_or_sealed_helper (obj_p,
+                                                            builtin_routine_id);
+      }
+      case ECMA_OBJECT_ROUTINE_IS_EXTENSIBLE:
+      {
+        return ecma_builtin_object_object_is_extensible (obj_p);
+      }
+      default:
+      {
+        JERRY_UNREACHABLE ();
+      }
     }
   }
 } /* ecma_builtin_object_dispatch_routine */

jerry-core/ecma/builtin-objects/ecma-builtin-object.h

@@ -0,0 +1,32 @@
+/* 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.
+ */
+#ifndef ECMA_BUILTIN_OBJECT_H
+#define ECMA_BUILTIN_OBJECT_H
+
+ecma_value_t ecma_builtin_object_object_get_prototype_of (ecma_object_t *obj_p);
+
+ecma_value_t ecma_builtin_object_object_set_prototype_of (ecma_value_t arg1,
+                                                          ecma_value_t arg2);
+ecma_value_t ecma_builtin_object_object_prevent_extensions (ecma_object_t *obj_p);
+
+ecma_value_t ecma_builtin_object_object_is_extensible (ecma_object_t *obj_p);
+
+ecma_value_t ecma_builtin_object_object_get_own_property_descriptor (ecma_object_t *obj_p,
+                                                                     ecma_string_t *name_str_p);
+ecma_value_t ecma_builtin_object_object_define_property (ecma_object_t *obj_p,
+                                                         ecma_string_t *name_str_p,
+                                                         ecma_value_t arg3);
+
+#endif /* !ECMA_BUILTIN_OBJECT_H */

jerry-core/ecma/builtin-objects/ecma-builtin-object.inc.h

@@ -39,9 +39,9 @@ OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
 ROUTINE (LIT_MAGIC_STRING_GET_PROTOTYPE_OF_UL, ECMA_OBJECT_ROUTINE_GET_PROTOTYPE_OF, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_GET_OWN_PROPERTY_NAMES_UL, ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_NAMES, 1, 1)
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_GET_OWN_PROPERTY_SYMBOLS_UL, ECMA_OBJECT_ROUTINE_GET_OWN_PROPERTY_SYMBOLS, 1, 1)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 ROUTINE (LIT_MAGIC_STRING_SEAL, ECMA_OBJECT_ROUTINE_SEAL, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_FREEZE, ECMA_OBJECT_ROUTINE_FREEZE, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_PREVENT_EXTENSIONS_UL, ECMA_OBJECT_ROUTINE_PREVENT_EXTENSIONS, 1, 1)
@@ -54,9 +54,10 @@ ROUTINE (LIT_MAGIC_STRING_CREATE, ECMA_OBJECT_ROUTINE_CREATE, 2, 2)
 ROUTINE (LIT_MAGIC_STRING_DEFINE_PROPERTIES_UL, ECMA_OBJECT_ROUTINE_DEFINE_PROPERTIES, 2, 2)
 ROUTINE (LIT_MAGIC_STRING_DEFINE_PROPERTY_UL, ECMA_OBJECT_ROUTINE_DEFINE_PROPERTY, 3, 3)
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_SET_PROTOTYPE_OF_UL, ECMA_OBJECT_ROUTINE_SET_PROTOTYPE_OF, 2, 2)
 ROUTINE (LIT_MAGIC_STRING_ASSIGN, ECMA_OBJECT_ROUTINE_ASSIGN, NON_FIXED, 2)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
+ROUTINE (LIT_MAGIC_STRING_IS, ECMA_OBJECT_ROUTINE_IS, 2, 2)
+#endif /* ENABLED (JERRY_ES2015) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-promise-prototype.inc.h

@@ -28,12 +28,12 @@ NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH,
               1,
               ECMA_PROPERTY_FLAG_WRITABLE)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 25.4.5.4 */
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_PROMISE_UL,
               ECMA_PROPERTY_FLAG_CONFIGURABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 ROUTINE (LIT_MAGIC_STRING_THEN, ecma_builtin_promise_prototype_then, 2, 2)
 ROUTINE (LIT_MAGIC_STRING_CATCH, ecma_builtin_promise_prototype_catch, 1, 1)

jerry-core/ecma/builtin-objects/ecma-builtin-promise.c

@@ -19,6 +19,7 @@
 #include "ecma-function-object.h"
 #include "ecma-gc.h"
 #include "ecma-globals.h"
+#include "ecma-iterator-object.h"
 #include "ecma-number-object.h"
 #include "ecma-promise-object.h"
 #include "jcontext.h"
@@ -42,78 +43,6 @@
  * @{
  */
 
-/**
- * The common function for 'reject' and 'resolve'.
- *
- * @return ecma value
- *         Returned value must be freed with ecma_free_value.
- */
-static ecma_value_t
-ecma_builtin_promise_reject_or_resolve (ecma_value_t this_arg, /**< "this" argument */
-                                        ecma_value_t argument, /**< argument for reject or resolve */
-                                        bool is_resolve) /**< whether it is for resolve routine */
-{
-  if (!ecma_is_value_object (this_arg))
-  {
-    return ecma_raise_type_error (ECMA_ERR_MSG ("'this' is not an object."));
-  }
-
-  uint8_t builtin_id = ecma_get_object_builtin_id (ecma_get_object_from_value (this_arg));
-
-  if (builtin_id != ECMA_BUILTIN_ID_PROMISE)
-  {
-    return ecma_raise_type_error (ECMA_ERR_MSG ("'this' is not the Promise constructor."));
-  }
-
-  if (is_resolve
-      && ecma_is_value_object (argument)
-      && ecma_is_promise (ecma_get_object_from_value (argument)))
-  {
-    return ecma_copy_value (argument);
-  }
-
-
-  ecma_value_t capability = ecma_promise_new_capability ();
-
-  if (ECMA_IS_VALUE_ERROR (capability))
-  {
-    return capability;
-  }
-
-  ecma_string_t *property_str_p;
-
-  if (is_resolve)
-  {
-    property_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_RESOLVE);
-  }
-  else
-  {
-    property_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REJECT);
-  }
-
-  ecma_value_t func = ecma_op_object_get (ecma_get_object_from_value (capability), property_str_p);
-
-  ecma_value_t call_ret = ecma_op_function_call (ecma_get_object_from_value (func),
-                                                 ECMA_VALUE_UNDEFINED,
-                                                 &argument,
-                                                 1);
-
-  ecma_free_value (func);
-
-  if (ECMA_IS_VALUE_ERROR (call_ret))
-  {
-    return call_ret;
-  }
-
-  ecma_free_value (call_ret);
-
-  ecma_string_t *promise_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_PROMISE);
-  ecma_value_t promise_new = ecma_op_object_get (ecma_get_object_from_value (capability), promise_str_p);
-  ecma_free_value (capability);
-
-  return promise_new;
-} /* ecma_builtin_promise_reject_or_resolve */
-
 /**
  * Reject the promise if the value is error.
  *
@@ -124,12 +53,17 @@ ecma_builtin_promise_reject_or_resolve (ecma_value_t this_arg, /**< "this" argum
  *         Returned value must be freed with ecma_free_value.
  */
 inline static ecma_value_t
-ecma_builtin_promise_reject_abrupt (ecma_value_t capability) /**< reject description */
+ecma_builtin_promise_reject_abrupt (ecma_value_t value, /**< value */
+                                    ecma_value_t capability) /**< capability */
 {
-  ecma_raise_type_error (ECMA_ERR_MSG ("Second argument is not an array."));
-  ecma_value_t reason = JERRY_CONTEXT (error_value);
-  ecma_string_t *reject_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REJECT);
-  ecma_value_t reject = ecma_op_object_get (ecma_get_object_from_value (capability), reject_str_p);
+  if (!ECMA_IS_VALUE_ERROR (value))
+  {
+    return value;
+  }
+
+  ecma_value_t reason = jcontext_take_exception ();
+  ecma_value_t reject = ecma_op_object_get_by_magic_id (ecma_get_object_from_value (capability),
+                                                        LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REJECT);
 
   ecma_value_t call_ret = ecma_op_function_call (ecma_get_object_from_value (reject),
                                                  ECMA_VALUE_UNDEFINED,
@@ -145,10 +79,8 @@ ecma_builtin_promise_reject_abrupt (ecma_value_t capability) /**< reject descrip
 
   ecma_free_value (call_ret);
 
-  ecma_string_t *promise_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_PROMISE);
-  ecma_value_t promise_new = ecma_op_object_get (ecma_get_object_from_value (capability), promise_str_p);
-
-  return promise_new;
+  return ecma_op_object_get_by_magic_id (ecma_get_object_from_value (capability),
+                                         LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_PROMISE);
 } /* ecma_builtin_promise_reject_abrupt */
 
 /**
@@ -164,7 +96,7 @@ static ecma_value_t
 ecma_builtin_promise_reject (ecma_value_t this_arg, /**< 'this' argument */
                              ecma_value_t reason) /**< the reason for reject */
 {
-  return ecma_builtin_promise_reject_or_resolve (this_arg, reason, false);
+  return ecma_promise_reject_or_resolve (this_arg, reason, false);
 } /* ecma_builtin_promise_reject */
 
 /**
@@ -180,7 +112,7 @@ static ecma_value_t
 ecma_builtin_promise_resolve (ecma_value_t this_arg, /**< 'this' argument */
                               ecma_value_t argument) /**< the argument for resolve */
 {
-  return ecma_builtin_promise_reject_or_resolve (this_arg, argument, true);
+  return ecma_promise_reject_or_resolve (this_arg, argument, true);
 } /* ecma_builtin_promise_resolve */
 
 /**
@@ -193,84 +125,80 @@ ecma_builtin_promise_resolve (ecma_value_t this_arg, /**< 'this' argument */
  *         Returned value must be freed with ecma_free_value.
  */
 inline static ecma_value_t
-ecma_builtin_promise_do_race (ecma_value_t array, /**< the array for race */
-                              ecma_value_t capability, /**< PromiseCapability record */
-                              ecma_value_t ctor) /**< the caller of Promise.race */
+ecma_builtin_promise_perform_race (ecma_value_t iterator, /**< the iterator for race */
+                                   ecma_value_t capability, /**< PromiseCapability record */
+                                   ecma_value_t ctor, /**< Constructor value */
+                                   bool *done_p) /**< [out] iteratorRecord[[done]] */
 {
-  JERRY_ASSERT (ecma_is_value_object (capability)
-                && ecma_is_value_object (array)
-                && ecma_is_value_object (ctor));
-  JERRY_ASSERT (ecma_get_object_builtin_id (ecma_get_object_from_value (ctor)) == ECMA_BUILTIN_ID_PROMISE);
-  JERRY_ASSERT (ecma_get_object_type (ecma_get_object_from_value (array)) == ECMA_OBJECT_TYPE_ARRAY);
+  JERRY_ASSERT (ecma_is_value_object (iterator)
+                && ecma_is_value_object (capability));
 
-  ecma_value_t ret = ECMA_VALUE_EMPTY;
-  ecma_object_t *array_p = ecma_get_object_from_value (array);
-  ecma_extended_object_t *ext_array_p = (ecma_extended_object_t *) array_p;
-
-  ecma_length_t len = ext_array_p->u.array.length;
-
-  ecma_string_t *promise_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_PROMISE);
-  ecma_string_t *resolve_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_RESOLVE);
-  ecma_string_t *reject_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REJECT);
-
-  ecma_value_t resolve = ecma_op_object_get (ecma_get_object_from_value (capability),
-                                             resolve_str_p);
-  ecma_value_t reject = ecma_op_object_get (ecma_get_object_from_value (capability),
-                                            reject_str_p);
-
-  for (ecma_length_t index = 0; index <= len; index++)
+  ecma_object_t *capability_obj_p = ecma_get_object_from_value (capability);
+  /* 1. */
+  while (true)
   {
-    /* b-d. */
-    if (index == len)
+    /* a. */
+    ecma_value_t next = ecma_op_iterator_step (iterator);
+    /* b, c. */
+    if (ECMA_IS_VALUE_ERROR (next))
     {
-      ret = ecma_op_object_get (ecma_get_object_from_value (capability), promise_str_p);
-      break;
+      *done_p = true;
+      return next;
+    }
+
+    /* d. */
+    if (ecma_is_value_false (next))
+    {
+      /* i. */
+      *done_p = true;
+      /* ii. */
+      return ecma_op_object_get_by_magic_id (capability_obj_p, LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_PROMISE);
     }
 
     /* e. */
-    ecma_string_t *index_to_str_p = ecma_new_ecma_string_from_uint32 (index);
-    ecma_value_t array_item = ecma_op_object_get (array_p, index_to_str_p);
-    ecma_deref_ecma_string (index_to_str_p);
+    ecma_value_t next_val = ecma_op_iterator_value (next);
+    ecma_free_value (next);
 
-    /* f. */
-    if (ECMA_IS_VALUE_ERROR (array_item))
+    /* f, g. */
+    if (ECMA_IS_VALUE_ERROR (next_val))
     {
-      ret = array_item;
-      break;
+      *done_p = true;
+      return next_val;
     }
 
     /* h. */
-    ecma_value_t next_promise = ecma_builtin_promise_resolve (ctor, array_item);
-    ecma_free_value (array_item);
+    ecma_value_t next_promise = ecma_op_invoke_by_magic_id (ctor, LIT_MAGIC_STRING_RESOLVE, &next_val, 1);
+    ecma_free_value (next_val);
 
     /* i. */
     if (ECMA_IS_VALUE_ERROR (next_promise))
     {
-      ret = next_promise;
-      break;
+      return next_promise;
     }
 
     /* j. */
-    ecma_value_t then_result = ecma_promise_then (next_promise, resolve, reject);
+    ecma_value_t args[2];
+    args[0] = ecma_op_object_get_by_magic_id (capability_obj_p, LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_RESOLVE);
+    args[1] = ecma_op_object_get_by_magic_id (capability_obj_p, LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REJECT);
+    ecma_value_t result = ecma_op_invoke_by_magic_id (next_promise, LIT_MAGIC_STRING_THEN, args, 2);
     ecma_free_value (next_promise);
 
-    /* k. */
-    if (ECMA_IS_VALUE_ERROR (then_result))
+    for (uint8_t i = 0; i < 2; i++)
     {
-      ret = then_result;
-      break;
+      ecma_free_value (args[i]);
     }
 
-    ecma_free_value (then_result);
+    /* k. */
+    if (ECMA_IS_VALUE_ERROR (result))
+    {
+      return result;
+    }
+
+    ecma_free_value (result);
   }
 
-  ecma_free_value (reject);
-  ecma_free_value (resolve);
-
-  JERRY_ASSERT (!ecma_is_value_empty (ret));
-
-  return ret;
-} /* ecma_builtin_promise_do_race */
+  JERRY_UNREACHABLE ();
+} /* ecma_builtin_promise_perform_race */
 
 /**
  * Helper function for increase or decrease the remaining count.
@@ -300,7 +228,6 @@ ecma_builtin_promise_remaining_inc_or_dec (ecma_value_t remaining, /**< the rema
   {
     current--;
   }
-
   ext_object_p->u.class_prop.u.value = ecma_make_uint32_value (current);
 
   return current;
@@ -323,7 +250,6 @@ ecma_builtin_promise_all_handler (const ecma_value_t function, /**< the function
   JERRY_UNUSED (this);
   JERRY_UNUSED (argc);
 
-  ecma_value_t ret = ECMA_VALUE_UNDEFINED;
   /* 1. */
   ecma_object_t *function_p = ecma_get_object_from_value (function);
   ecma_string_t *already_called_str_p;
@@ -335,8 +261,7 @@ ecma_builtin_promise_all_handler (const ecma_value_t function, /**< the function
   /* 2. */
   if (ecma_is_value_true (already_called))
   {
-    ecma_fast_free_value (already_called);
-    return ret;
+    return ECMA_VALUE_UNDEFINED;
   }
 
   /* 3. */
@@ -352,39 +277,35 @@ ecma_builtin_promise_all_handler (const ecma_value_t function, /**< the function
 
   /* 4-7. */
   ecma_value_t index_val = ecma_op_object_get (function_p, str_index_p);
-  ecma_value_t value_array = ecma_op_object_get (function_p, str_value_p);
+  ecma_value_t values_array = ecma_op_object_get (function_p, str_value_p);
   ecma_value_t capability = ecma_op_object_get (function_p, str_capability_p);
   ecma_value_t remaining = ecma_op_object_get (function_p, str_remaining_p);
 
   JERRY_ASSERT (ecma_is_value_integer_number (index_val));
 
   /* 8. */
-  ecma_string_t *index_to_str_p = ecma_new_ecma_string_from_uint32 ((uint32_t) ecma_get_integer_from_value (index_val));
-
-  ecma_op_object_put (ecma_get_object_from_value (value_array),
-                      index_to_str_p,
-                      argv[0],
-                      false);
-  ecma_deref_ecma_string (index_to_str_p);
+  ecma_op_object_put_by_uint32_index (ecma_get_object_from_value (values_array),
+                                      (uint32_t) ecma_get_integer_from_value (index_val),
+                                      argv[0],
+                                      false);
 
   /* 9-10. */
+  ecma_value_t ret = ECMA_VALUE_UNDEFINED;
   if (ecma_builtin_promise_remaining_inc_or_dec (remaining, false) == 0)
   {
-    ecma_string_t *resolve_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_RESOLVE);
-    ecma_value_t resolve = ecma_op_object_get (ecma_get_object_from_value (capability), resolve_str_p);
-
+    ecma_value_t resolve = ecma_op_object_get_by_magic_id (ecma_get_object_from_value (capability),
+                                                           LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_RESOLVE);
     ret = ecma_op_function_call (ecma_get_object_from_value (resolve),
                                  ECMA_VALUE_UNDEFINED,
-                                 &value_array,
+                                 &values_array,
                                  1);
     ecma_free_value (resolve);
   }
 
   ecma_free_value (remaining);
   ecma_free_value (capability);
-  ecma_free_value (value_array);
-  ecma_fast_free_value (index_val);
-  ecma_fast_free_value (already_called);
+  ecma_free_value (values_array);
+  ecma_free_value (index_val);
 
   return ret;
 } /* ecma_builtin_promise_all_handler */
@@ -399,25 +320,25 @@ ecma_builtin_promise_all_handler (const ecma_value_t function, /**< the function
  *         Returned value must be freed with ecma_free_value.
  */
 inline static ecma_value_t
-ecma_builtin_promise_do_all (ecma_value_t array, /**< the array for all */
-                             ecma_value_t capability, /**< PromiseCapability record */
-                             ecma_value_t ctor) /**< the caller of Promise.race */
+ecma_builtin_promise_perform_all (ecma_value_t iterator, /**< iteratorRecord */
+                                  ecma_value_t ctor, /**< the caller of Promise.race */
+                                  ecma_value_t capability,  /**< PromiseCapability record */
+                                  bool *done_p) /**< [out] iteratorRecord[[done]] */
 {
-  JERRY_ASSERT (ecma_is_value_object (capability)
-                && ecma_is_value_object (array)
-                && ecma_is_value_object (ctor));
-  JERRY_ASSERT (ecma_get_object_builtin_id (ecma_get_object_from_value (ctor)) == ECMA_BUILTIN_ID_PROMISE);
-  JERRY_ASSERT (ecma_get_object_type (ecma_get_object_from_value (array)) == ECMA_OBJECT_TYPE_ARRAY);
+  /* 1. - 2. */
+  JERRY_ASSERT (ecma_is_value_object (capability) && ecma_is_constructor (ctor));
 
-  ecma_value_t ret = ECMA_VALUE_EMPTY;
-  ecma_object_t *array_p = ecma_get_object_from_value (array);
-  ecma_extended_object_t *ext_array_p = (ecma_extended_object_t *) array_p;
+  /* 3. */
+  ecma_object_t *values_array_obj_p = ecma_op_new_fast_array_object (0);
+  ecma_value_t values_array = ecma_make_object_value (values_array_obj_p);
+  /* 4. */
+  ecma_value_t remaining = ecma_op_create_number_object (ecma_make_integer_value (1));
+  /* 5. */
+  uint32_t idx = 0;
 
-  ecma_length_t len = ext_array_p->u.array.length;
+  ecma_value_t ret_value = ECMA_VALUE_ERROR;
+  ecma_object_t *capability_obj_p = ecma_get_object_from_value (capability);
 
-  ecma_string_t *promise_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_PROMISE);
-  ecma_string_t *resolve_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_RESOLVE);
-  ecma_string_t *reject_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REJECT);
   ecma_string_t *already_called_str_p;
   already_called_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_ALREADY_CALLED);
   ecma_string_t *index_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_INDEX);
@@ -425,81 +346,75 @@ ecma_builtin_promise_do_all (ecma_value_t array, /**< the array for all */
   ecma_string_t *capability_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_CAPABILITY);
   ecma_string_t *remaining_str_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REMAINING_ELEMENT);
 
-  ecma_value_t undefined_val = ECMA_VALUE_UNDEFINED;
-  /* String '1' indicates [[Resolve]] and '2' indicates [[Reject]]. */
-  ecma_value_t resolve = ecma_op_object_get (ecma_get_object_from_value (capability),
-                                             resolve_str_p);
-  ecma_value_t reject = ecma_op_object_get (ecma_get_object_from_value (capability),
-                                            reject_str_p);
-  /* 3. */
-  ecma_value_t result_array_length_val = ecma_make_uint32_value (0);
-  ecma_value_t value_array = ecma_op_create_array_object (&result_array_length_val, 1, true);
-  ecma_free_value (result_array_length_val);
-  /* 4. */
-  ecma_value_t remaining = ecma_op_create_number_object (ecma_make_integer_value (1));
-  /* 5. */
-  ecma_length_t index = 0;
-
-  /* 6 */
+  /* 6. */
   while (true)
   {
-    JERRY_ASSERT (index <= len);
-    /* d. */
-    if (index == len)
+    /* a. */
+    ecma_value_t next = ecma_op_iterator_step (iterator);
+    /* b. - c. */
+    if (ECMA_IS_VALUE_ERROR (next))
     {
-      /* ii. */
+      *done_p = true;
+      break;
+    }
+
+    /* d. */
+    if (ecma_is_value_false (next))
+    {
+      /* i. */
+      *done_p = true;
+
+      /* ii. - iii. */
       if (ecma_builtin_promise_remaining_inc_or_dec (remaining, false) == 0)
       {
-        /* iii. */
-        ecma_value_t resolve_ret = ecma_op_function_call (ecma_get_object_from_value (resolve),
-                                                          ECMA_VALUE_UNDEFINED,
-                                                          &value_array,
-                                                          1);
+        /* 2. */
+        ecma_value_t resolve = ecma_op_object_get_by_magic_id (capability_obj_p,
+                                                               LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_RESOLVE);
+        ecma_value_t resolve_result = ecma_op_function_call (ecma_get_object_from_value (resolve),
+                                                             ECMA_VALUE_UNDEFINED,
+                                                             &values_array,
+                                                             1);
+        ecma_free_value (resolve);
 
-        if (ECMA_IS_VALUE_ERROR (resolve_ret))
+        /* 3. */
+        if (ECMA_IS_VALUE_ERROR (resolve_result))
         {
-          ret = resolve_ret;
           break;
         }
+
+        ecma_free_value (resolve_result);
       }
 
       /* iv. */
-      ret = ecma_op_object_get (ecma_get_object_from_value (capability), promise_str_p);
+      ret_value = ecma_op_object_get_by_magic_id (capability_obj_p,
+                                                  LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_PROMISE);
       break;
     }
 
-    /* e. h. */
-    ecma_string_t *index_to_str_p = ecma_new_ecma_string_from_uint32 (index);
-    ecma_value_t array_item = ecma_op_object_get (array_p, index_to_str_p);
+    /* e. */
+    ecma_value_t next_value = ecma_op_iterator_value (next);
+    ecma_free_value (next);
 
-    if (ECMA_IS_VALUE_ERROR (array_item))
+    /* f. - g. */
+    if (ECMA_IS_VALUE_ERROR (next_value))
     {
-      ecma_deref_ecma_string (index_to_str_p);
-      ret = array_item;
+      *done_p = true;
       break;
     }
 
-    ecma_value_t put_ret = ecma_builtin_helper_def_prop (ecma_get_object_from_value (value_array),
-                                                         index_to_str_p,
-                                                         undefined_val,
-                                                         ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
-    ecma_deref_ecma_string (index_to_str_p);
-
-    if (ECMA_IS_VALUE_ERROR (put_ret))
-    {
-      ecma_free_value (array_item);
-      ret = put_ret;
-      break;
-    }
+    /* h. */
+    ecma_builtin_helper_def_prop_by_index (values_array_obj_p,
+                                           idx,
+                                           ECMA_VALUE_UNDEFINED,
+                                           ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE);
 
     /* i. */
-    ecma_value_t next_promise = ecma_builtin_promise_resolve (ctor, array_item);
-    ecma_free_value (array_item);
+    ecma_value_t next_promise = ecma_op_invoke_by_magic_id (ctor, LIT_MAGIC_STRING_RESOLVE, &next_value, 1);
+    ecma_free_value (next_value);
 
     /* j. */
     if (ECMA_IS_VALUE_ERROR (next_promise))
     {
-      ret = next_promise;
       break;
     }
 
@@ -512,15 +427,19 @@ ecma_builtin_promise_do_all (ecma_value_t array, /**< the array for all */
                         ECMA_VALUE_FALSE,
                         false);
     /* m. */
+    ecma_value_t idx_value = ecma_make_uint32_value (idx);
     ecma_op_object_put (res_ele_p,
                         index_str_p,
-                        ecma_make_uint32_value (index),
+                        idx_value,
                         false);
+    ecma_free_value (idx_value);
+
     /* n. */
     ecma_op_object_put (res_ele_p,
                         value_str_p,
-                        value_array,
+                        values_array,
                         false);
+
     /* o. */
     ecma_op_object_put (res_ele_p,
                         capability_str_p,
@@ -534,33 +453,35 @@ ecma_builtin_promise_do_all (ecma_value_t array, /**< the array for all */
 
     /* q. */
     ecma_builtin_promise_remaining_inc_or_dec (remaining, true);
+
     /* r. */
-    ecma_value_t then_result = ecma_promise_then (next_promise,
-                                                  ecma_make_object_value (res_ele_p),
-                                                  reject);
-    ecma_deref_object (res_ele_p);
+    ecma_value_t args[2];
+    args[0] = ecma_make_object_value (res_ele_p);
+    args[1] = ecma_op_object_get_by_magic_id (capability_obj_p, LIT_INTERNAL_MAGIC_STRING_PROMISE_PROPERTY_REJECT);
+    ecma_value_t result = ecma_op_invoke_by_magic_id (next_promise, LIT_MAGIC_STRING_THEN, args, 2);
     ecma_free_value (next_promise);
 
-    /* s. */
-    if (ECMA_IS_VALUE_ERROR (then_result))
+    for (uint8_t i = 0; i < 2; i++)
+    {
+      ecma_free_value (args[i]);
+    }
+
+    /* s. */
+    if (ECMA_IS_VALUE_ERROR (result))
     {
-      ret = then_result;
       break;
     }
 
-    ecma_free_value (then_result);
-    index ++;
+    ecma_free_value (result);
+
+    /* t. */
+    idx++;
   }
 
-  ecma_free_value (reject);
-  ecma_free_value (resolve);
   ecma_free_value (remaining);
-  ecma_free_value (value_array);
-
-  JERRY_ASSERT (!ecma_is_value_empty (ret));
-
-  return ret;
-} /* ecma_builtin_promise_do_all */
+  ecma_deref_object (values_array_obj_p);
+  return ret_value;
+} /* ecma_builtin_promise_perform_all */
 
 /**
  * The common function for both Promise.race and Promise.all.
@@ -570,7 +491,7 @@ ecma_builtin_promise_do_all (ecma_value_t array, /**< the array for all */
  */
 static ecma_value_t
 ecma_builtin_promise_race_or_all (ecma_value_t this_arg, /**< 'this' argument */
-                                  ecma_value_t array, /**< the items to be resolved */
+                                  ecma_value_t iterable, /**< the items to be resolved */
                                   bool is_race) /**< indicates whether it is race function */
 {
   if (!ecma_is_value_object (this_arg))
@@ -578,44 +499,69 @@ ecma_builtin_promise_race_or_all (ecma_value_t this_arg, /**< 'this' argument */
     return ecma_raise_type_error (ECMA_ERR_MSG ("'this' is not an object."));
   }
 
-  uint8_t builtin_id = ecma_get_object_builtin_id (ecma_get_object_from_value (this_arg));
+  ecma_object_t *this_obj_p = ecma_get_object_from_value (this_arg);
+  ecma_value_t species_symbol = ecma_op_object_get_by_magic_id (this_obj_p,
+                                                                LIT_MAGIC_STRING_SYMBOL);
 
-  if (builtin_id != ECMA_BUILTIN_ID_PROMISE)
+  if (ECMA_IS_VALUE_ERROR (species_symbol))
   {
-    return ecma_raise_type_error (ECMA_ERR_MSG ("'this' is not the Promise constructor."));
+    return species_symbol;
   }
 
-  ecma_value_t capability = ecma_promise_new_capability ();
+  ecma_value_t constructor_value = this_arg;
 
-  if (ECMA_IS_VALUE_ERROR (capability))
+  if (!ecma_is_value_null (species_symbol) && !ecma_is_value_undefined (species_symbol))
   {
-    return capability;
-  }
-
-  ecma_value_t ret = ECMA_VALUE_EMPTY;
-
-  if (!ecma_is_value_object (array)
-      || ecma_get_object_type (ecma_get_object_from_value (array)) != ECMA_OBJECT_TYPE_ARRAY)
-  {
-    ret = ecma_builtin_promise_reject_abrupt (capability);
-    ecma_free_value (capability);
-    return ret;
-  }
-
-  if (is_race)
-  {
-    ret = ecma_builtin_promise_do_race (array, capability, this_arg);
+    constructor_value = species_symbol;
   }
   else
   {
-    ret = ecma_builtin_promise_do_all (array, capability, this_arg);
+    ecma_ref_object (this_obj_p);
   }
 
+  ecma_value_t capability = ecma_promise_new_capability (constructor_value);
+
+  if (ECMA_IS_VALUE_ERROR (capability))
+  {
+    ecma_free_value (constructor_value);
+    return capability;
+  }
+
+  ecma_value_t iterator = ecma_builtin_promise_reject_abrupt (ecma_op_get_iterator (iterable, ECMA_VALUE_EMPTY),
+                                                              capability);
+
+  if (ECMA_IS_VALUE_ERROR (iterator))
+  {
+    ecma_free_value (constructor_value);
+    ecma_free_value (capability);
+    return iterator;
+  }
+
+  ecma_value_t ret = ECMA_VALUE_EMPTY;
+  bool is_done = false;
+
+  if (is_race)
+  {
+    ret = ecma_builtin_promise_perform_race (iterator, capability, constructor_value, &is_done);
+  }
+  else
+  {
+    ret = ecma_builtin_promise_perform_all (iterator, constructor_value, capability, &is_done);
+  }
+
+  ecma_free_value (constructor_value);
+
   if (ECMA_IS_VALUE_ERROR (ret))
   {
-    ret = JERRY_CONTEXT (error_value);
+    if (is_done)
+    {
+      ret = ecma_op_iterator_close (iterator);
+    }
+
+    ret = ecma_builtin_promise_reject_abrupt (ret, capability);
   }
 
+  ecma_free_value (iterator);
   ecma_free_value (capability);
 
   return ret;
@@ -690,6 +636,18 @@ ecma_builtin_promise_dispatch_construct (const ecma_value_t *arguments_list_p, /
   return ecma_op_create_promise_object (arguments_list_p[0], ECMA_PROMISE_EXECUTOR_FUNCTION);
 } /* ecma_builtin_promise_dispatch_construct */
 
+/**
+ * 25.4.4.6 get Promise [ @@species ] accessor
+ *
+ * @return ecma_value
+ *         returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_builtin_promise_species_get (ecma_value_t this_value) /**< This Value */
+{
+  return ecma_copy_value (this_value);
+} /* ecma_builtin_promise_species_get */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-promise.inc.h

@@ -42,6 +42,11 @@ ROUTINE (LIT_MAGIC_STRING_RESOLVE, ecma_builtin_promise_resolve, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_RACE, ecma_builtin_promise_race, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_ALL, ecma_builtin_promise_all, 1, 1)
 
+/* ES2015 25.4.4.6 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES,
+                    ecma_builtin_promise_species_get,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_PROMISE) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-reflect.c

@@ -0,0 +1,176 @@
+/* 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 "ecma-builtins.h"
+#include "ecma-builtin-function-prototype.h"
+#include "ecma-builtin-object.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "jcontext.h"
+
+#if ENABLED (JERRY_ES2015_BUILTIN_REFLECT)
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_REFLECT_OBJECT_ROUTINE_START = ECMA_BUILTIN_ID__COUNT - 1,
+  ECMA_REFLECT_OBJECT_GET_PROTOTYPE_OF_UL, /* ECMA-262 v6, 26.1.8 */
+  ECMA_REFLECT_OBJECT_SET_PROTOTYPE_OF_UL, /* ECMA-262 v6, 26.1.14 */
+  ECMA_REFLECT_OBJECT_APPLY, /* ECMA-262 v6, 26.1.1 */
+  ECMA_REFLECT_OBJECT_DEFINE_PROPERTY, /* ECMA-262 v6, 26.1.3 */
+  ECMA_REFLECT_OBJECT_GET_OWN_PROPERTY_DESCRIPTOR_UL, /* ECMA-262 v5, 26.1.7 */
+  ECMA_REFLECT_OBJECT_IS_EXTENSIBLE, /* ECMA-262 v6, 26.1.10 */
+  ECMA_REFLECT_OBJECT_PREVENT_EXTENSIONS_UL, /* ECMA-262 v6, 26.1.12 */
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-reflect.inc.h"
+#define BUILTIN_UNDERSCORED_ID reflect
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup object ECMA Reflect object built-in
+ * @{
+ */
+
+/**
+ * Dispatcher for the built-in's routines.
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_reflect_dispatch_routine (uint16_t builtin_routine_id, /**< built-in wide routine
+                                                                     *   identifier */
+                                       ecma_value_t this_arg, /**< 'this' argument value */
+                                       const ecma_value_t arguments_list[], /**< list of arguments
+                                                                             *   passed to routine */
+                                       ecma_length_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED (this_arg);
+  JERRY_UNUSED (arguments_number);
+
+  if (!ecma_is_value_object (arguments_list[0]))
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("Argument is not an Object."));
+  }
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_REFLECT_OBJECT_GET_PROTOTYPE_OF_UL:
+    {
+      return ecma_builtin_object_object_get_prototype_of (ecma_get_object_from_value (arguments_list[0]));
+    }
+    case ECMA_REFLECT_OBJECT_SET_PROTOTYPE_OF_UL:
+    {
+      ecma_value_t result = ecma_builtin_object_object_set_prototype_of (arguments_list[0], arguments_list[1]);
+      bool is_error = ECMA_IS_VALUE_ERROR (result);
+
+      if (is_error)
+      {
+        jcontext_release_exception ();
+      }
+      else
+      {
+        ecma_free_value (result);
+      }
+
+      return ecma_make_boolean_value (!is_error);
+    }
+    case ECMA_REFLECT_OBJECT_APPLY:
+    {
+      if (!ecma_op_is_callable (arguments_list[0]))
+      {
+        return ecma_raise_type_error (ECMA_ERR_MSG ("Argument 'this' is not a function."));
+      }
+
+      ecma_object_t *func_obj_p = ecma_get_object_from_value (arguments_list[0]);
+      return ecma_builtin_function_prototype_object_apply (func_obj_p, arguments_list[1], arguments_list[2]);
+    }
+    case ECMA_REFLECT_OBJECT_DEFINE_PROPERTY:
+    {
+      ecma_object_t *obj_p = ecma_get_object_from_value (arguments_list[0]);
+      ecma_string_t *name_str_p = ecma_op_to_prop_name (arguments_list[1]);
+
+      if (name_str_p == NULL)
+      {
+        return ECMA_VALUE_ERROR;
+      }
+
+      ecma_value_t result = ecma_builtin_object_object_define_property (obj_p, name_str_p, arguments_list[2]);
+      ecma_deref_ecma_string (name_str_p);
+      bool is_error = ECMA_IS_VALUE_ERROR (result);
+
+      if (is_error)
+      {
+        jcontext_release_exception ();
+      }
+      else
+      {
+        ecma_free_value (result);
+      }
+
+      return ecma_make_boolean_value (!is_error);
+    }
+    case ECMA_REFLECT_OBJECT_GET_OWN_PROPERTY_DESCRIPTOR_UL:
+    {
+      ecma_object_t *obj_p = ecma_get_object_from_value (arguments_list[0]);
+      ecma_string_t *name_str_p = ecma_op_to_prop_name (arguments_list[1]);
+
+      if (name_str_p == NULL)
+      {
+        return ECMA_VALUE_ERROR;
+      }
+
+      ecma_value_t ret_val = ecma_builtin_object_object_get_own_property_descriptor (obj_p, name_str_p);
+      ecma_deref_ecma_string (name_str_p);
+      return ret_val;
+    }
+    case ECMA_REFLECT_OBJECT_IS_EXTENSIBLE:
+    {
+      ecma_object_t *obj_p = ecma_get_object_from_value (arguments_list[0]);
+      return ecma_builtin_object_object_is_extensible (obj_p);
+    }
+    default:
+    {
+      JERRY_ASSERT (builtin_routine_id == ECMA_REFLECT_OBJECT_PREVENT_EXTENSIONS_UL);
+      ecma_object_t *obj_p = ecma_get_object_from_value (arguments_list[0]);
+      return ecma_builtin_object_object_prevent_extensions (obj_p);
+    }
+  }
+} /* ecma_builtin_reflect_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_REFLECT) */

jerry-core/ecma/builtin-objects/ecma-builtin-reflect.inc.h

@@ -0,0 +1,32 @@
+/* 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 "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if ENABLED (JERRY_ES2015_BUILTIN_REFLECT)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_APPLY, ECMA_REFLECT_OBJECT_APPLY, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_DEFINE_PROPERTY_UL, ECMA_REFLECT_OBJECT_DEFINE_PROPERTY, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_GET_OWN_PROPERTY_DESCRIPTOR_UL, ECMA_REFLECT_OBJECT_GET_OWN_PROPERTY_DESCRIPTOR_UL, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_GET_PROTOTYPE_OF_UL, ECMA_REFLECT_OBJECT_GET_PROTOTYPE_OF_UL, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_IS_EXTENSIBLE, ECMA_REFLECT_OBJECT_IS_EXTENSIBLE, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_PREVENT_EXTENSIONS_UL, ECMA_REFLECT_OBJECT_PREVENT_EXTENSIONS_UL, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_PROTOTYPE_OF_UL, ECMA_REFLECT_OBJECT_SET_PROTOTYPE_OF_UL, 2, 2)
+
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_REFLECT) */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.c

@@ -16,11 +16,15 @@
 #include "ecma-alloc.h"
 #include "ecma-array-object.h"
 #include "ecma-builtins.h"
+#include "ecma-builtin-helpers.h"
 #include "ecma-conversion.h"
 #include "ecma-exceptions.h"
+#include "ecma-function-object.h"
 #include "ecma-globals.h"
+#include "ecma-gc.h"
 #include "ecma-helpers.h"
 #include "ecma-objects.h"
+#include "ecma-regexp-object.h"
 #include "ecma-try-catch-macro.h"
 #include "lit-char-helpers.h"
 
@@ -56,8 +60,7 @@ static ecma_value_t
 ecma_builtin_regexp_prototype_flags_helper (ecma_value_t this, /**< this value */
                                             uint16_t *flags_p) /**< [out] flags */
 {
-  if (!ecma_is_value_object (this)
-      || !ecma_object_class_is (ecma_get_object_from_value (this), LIT_MAGIC_STRING_REGEXP_UL))
+  if (!ecma_object_is_regexp_object (this))
   {
     return ecma_raise_type_error (ECMA_ERR_MSG ("Incompatible type"));
   }
@@ -88,31 +91,50 @@ ecma_builtin_regexp_prototype_flags_helper (ecma_value_t this, /**< this value *
 static ecma_value_t
 ecma_builtin_regexp_prototype_get_flags (ecma_value_t this_arg) /**< this argument */
 {
-  uint16_t flags = RE_FLAG_EMPTY;
-  ecma_value_t ret_value = ecma_builtin_regexp_prototype_flags_helper (this_arg, &flags);
-  if (ECMA_IS_VALUE_ERROR (ret_value))
+  static const lit_magic_string_id_t flag_lit_ids[] =
   {
-    return ret_value;
+    LIT_MAGIC_STRING_GLOBAL,
+    LIT_MAGIC_STRING_IGNORECASE_UL,
+    LIT_MAGIC_STRING_MULTILINE,
+    LIT_MAGIC_STRING_UNICODE,
+    LIT_MAGIC_STRING_STICKY
+  };
+
+  static const lit_utf8_byte_t flag_chars[] =
+  {
+    LIT_CHAR_LOWERCASE_G,
+    LIT_CHAR_LOWERCASE_I,
+    LIT_CHAR_LOWERCASE_M,
+    LIT_CHAR_LOWERCASE_U,
+    LIT_CHAR_LOWERCASE_Y
+  };
+
+  if (!ecma_is_value_object (this_arg))
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("'this' value is not an object."));
   }
 
-  ecma_stringbuilder_t result = ecma_stringbuilder_create ();
+  ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
 
-  if (flags & RE_FLAG_GLOBAL)
+  ecma_stringbuilder_t builder = ecma_stringbuilder_create ();
+  for (uint32_t i = 0; i < sizeof (flag_lit_ids) / sizeof (lit_magic_string_id_t); i++)
   {
-    ecma_stringbuilder_append_byte (&result, LIT_CHAR_LOWERCASE_G);
+    ecma_value_t result = ecma_op_object_get_by_magic_id (object_p, flag_lit_ids[i]);
+    if (ECMA_IS_VALUE_ERROR (result))
+    {
+      ecma_stringbuilder_destroy (&builder);
+      return result;
+    }
+
+    if (ecma_op_to_boolean (result))
+    {
+      ecma_stringbuilder_append_byte (&builder, flag_chars[i]);
+    }
+
+    ecma_free_value (result);
   }
 
-  if (flags & RE_FLAG_IGNORE_CASE)
-  {
-    ecma_stringbuilder_append_byte (&result, LIT_CHAR_LOWERCASE_I);
-  }
-
-  if (flags & RE_FLAG_MULTILINE)
-  {
-    ecma_stringbuilder_append_byte (&result, LIT_CHAR_LOWERCASE_M);
-  }
-
-  return ecma_make_string_value (ecma_stringbuilder_finalize (&result));
+  return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
 } /* ecma_builtin_regexp_prototype_get_flags */
 
 /**
@@ -129,8 +151,7 @@ ecma_builtin_regexp_prototype_get_flags (ecma_value_t this_arg) /**< this argume
 static ecma_value_t
 ecma_builtin_regexp_prototype_get_source (ecma_value_t this_arg) /**< this argument */
 {
-  if (!ecma_is_value_object (this_arg)
-      || !ecma_object_class_is (ecma_get_object_from_value (this_arg), LIT_MAGIC_STRING_REGEXP_UL))
+  if (!ecma_object_is_regexp_object (this_arg))
   {
     return ecma_raise_type_error (ECMA_ERR_MSG ("Incompatible type"));
   }
@@ -222,6 +243,56 @@ ecma_builtin_regexp_prototype_get_multiline (ecma_value_t this_arg) /**< this ar
 
   return ecma_make_boolean_value (flags & RE_FLAG_MULTILINE);
 } /* ecma_builtin_regexp_prototype_get_multiline */
+
+/**
+ * The RegExp.prototype object's 'sticky' accessor property
+ *
+ * See also:
+ *          ECMA-262 v6, 21.2.5.12
+ *
+ * @return ECMA_VALUE_ERROR - if 'this' is not a RegExp object
+ *         ECMA_VALUE_TRUE  - if 'sticky' flag is set
+ *         ECMA_VALUE_FALSE - otherwise
+ *
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_regexp_prototype_get_sticky (ecma_value_t this_arg) /**< this argument */
+{
+  uint16_t flags = RE_FLAG_EMPTY;
+  ecma_value_t ret_value = ecma_builtin_regexp_prototype_flags_helper (this_arg, &flags);
+  if (ECMA_IS_VALUE_ERROR (ret_value))
+  {
+    return ret_value;
+  }
+
+  return ecma_make_boolean_value (flags & RE_FLAG_STICKY);
+} /* ecma_builtin_regexp_prototype_get_sticky */
+
+/**
+ * The RegExp.prototype object's 'unicode' accessor property
+ *
+ * See also:
+ *          ECMA-262 v6, 21.2.5.15
+ *
+ * @return ECMA_VALUE_ERROR - if 'this' is not a RegExp object
+ *         ECMA_VALUE_TRUE  - if 'unicode' flag is set
+ *         ECMA_VALUE_FALSE - otherwise
+ *
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_regexp_prototype_get_unicode (ecma_value_t this_arg) /**< this argument */
+{
+  uint16_t flags = RE_FLAG_EMPTY;
+  ecma_value_t ret_value = ecma_builtin_regexp_prototype_flags_helper (this_arg, &flags);
+  if (ECMA_IS_VALUE_ERROR (ret_value))
+  {
+    return ret_value;
+  }
+
+  return ecma_make_boolean_value (flags & RE_FLAG_UNICODE);
+} /* ecma_builtin_regexp_prototype_get_unicode */
 #endif /* ENABLED (JERRY_ES2015) */
 
 #if ENABLED (JERRY_BUILTIN_ANNEXB)
@@ -242,8 +313,7 @@ ecma_builtin_regexp_prototype_compile (ecma_value_t this_arg, /**< this argument
                                        ecma_value_t pattern_arg, /**< pattern or RegExp object */
                                        ecma_value_t flags_arg) /**< flags */
 {
-  if (!ecma_is_value_object (this_arg)
-      || !ecma_object_class_is (ecma_get_object_from_value (this_arg), LIT_MAGIC_STRING_REGEXP_UL)
+  if (!ecma_object_is_regexp_object (this_arg)
       /* The builtin RegExp.prototype object does not have [[RegExpMatcher]] internal slot */
       || ecma_get_object_from_value (this_arg) == ecma_builtin_get (ECMA_BUILTIN_ID_REGEXP_PROTOTYPE))
   {
@@ -252,8 +322,7 @@ ecma_builtin_regexp_prototype_compile (ecma_value_t this_arg, /**< this argument
 
   uint16_t flags = 0;
 
-  if (ecma_is_value_object (pattern_arg)
-      && ecma_object_class_is (ecma_get_object_from_value (pattern_arg), LIT_MAGIC_STRING_REGEXP_UL)
+  if (ecma_object_is_regexp_object (pattern_arg)
       && ecma_get_object_from_value (pattern_arg) != ecma_builtin_get (ECMA_BUILTIN_ID_REGEXP_PROTOTYPE))
   {
     if (!ecma_is_value_undefined (flags_arg))
@@ -284,29 +353,27 @@ ecma_builtin_regexp_prototype_compile (ecma_value_t this_arg, /**< this argument
     return ecma_copy_value (this_arg);
   }
 
-  ecma_string_t *pattern_string_p = NULL;
+  ecma_string_t *pattern_string_p = ecma_regexp_read_pattern_str_helper (pattern_arg);
 
   /* Get source string. */
-  ecma_value_t ret_value = ecma_regexp_read_pattern_str_helper (pattern_arg, &pattern_string_p);
-  if (ECMA_IS_VALUE_ERROR (ret_value))
+  if (pattern_string_p == NULL)
   {
-    JERRY_ASSERT (pattern_string_p == NULL);
-    return ret_value;
+    return ECMA_VALUE_ERROR;
   }
-  JERRY_ASSERT (ecma_is_value_empty (ret_value));
 
   /* Parse flags. */
   if (!ecma_is_value_undefined (flags_arg))
   {
-    ecma_value_t flags_str_value = ecma_op_to_string (flags_arg);
-    if (ECMA_IS_VALUE_ERROR (flags_str_value))
+    ecma_string_t *flags_str_p = ecma_op_to_string (flags_arg);
+    if (JERRY_UNLIKELY (flags_str_p == NULL))
     {
       ecma_deref_ecma_string (pattern_string_p);
-      return flags_str_value;
+      return ECMA_VALUE_ERROR;
     }
 
-    ecma_value_t parsed_flags_val = ecma_regexp_parse_flags (ecma_get_string_from_value (flags_str_value), &flags);
-    ecma_free_value (flags_str_value);
+    ecma_value_t parsed_flags_val = ecma_regexp_parse_flags (flags_str_p, &flags);
+    ecma_deref_ecma_string (flags_str_p);
+
     if (ECMA_IS_VALUE_ERROR (parsed_flags_val))
     {
       ecma_deref_ecma_string (pattern_string_p);
@@ -355,8 +422,7 @@ static ecma_value_t
 ecma_builtin_regexp_prototype_exec (ecma_value_t this_arg, /**< this argument */
                                     ecma_value_t arg) /**< routine's argument */
 {
-  if (!ecma_is_value_object (this_arg)
-      || !ecma_object_class_is (ecma_get_object_from_value (this_arg), LIT_MAGIC_STRING_REGEXP_UL))
+  if (!ecma_object_is_regexp_object (this_arg))
   {
     return ecma_raise_type_error (ECMA_ERR_MSG ("Incomplete RegExp type"));
   }
@@ -367,17 +433,17 @@ ecma_builtin_regexp_prototype_exec (ecma_value_t this_arg, /**< this argument */
     return obj_this;
   }
 
-  ecma_value_t input_str_value = ecma_op_to_string (arg);
-  if (ECMA_IS_VALUE_ERROR (input_str_value))
+  ecma_string_t *input_str_p = ecma_op_to_string (arg);
+  if (JERRY_UNLIKELY (input_str_p == NULL))
   {
     ecma_free_value (obj_this);
-    return input_str_value;
+    return ECMA_VALUE_ERROR;
   }
 
-  ecma_value_t ret_value = ecma_regexp_exec_helper (obj_this, input_str_value, false);
+  ecma_value_t ret_value = ecma_regexp_exec_helper (ecma_get_object_from_value (obj_this), input_str_p);
 
   ecma_free_value (obj_this);
-  ecma_free_value (input_str_value);
+  ecma_deref_ecma_string (input_str_p);
 
   return ret_value;
 } /* ecma_builtin_regexp_prototype_exec */
@@ -422,10 +488,58 @@ ecma_builtin_regexp_prototype_test (ecma_value_t this_arg, /**< this argument */
 static ecma_value_t
 ecma_builtin_regexp_prototype_to_string (ecma_value_t this_arg) /**< this argument */
 {
-  if (!ecma_is_value_object (this_arg)
-      || !ecma_object_class_is (ecma_get_object_from_value (this_arg), LIT_MAGIC_STRING_REGEXP_UL))
+#if ENABLED (JERRY_ES2015)
+  if (!ecma_is_value_object (this_arg))
   {
-    return ecma_raise_type_error (ECMA_ERR_MSG ("Incompatible type"));
+    return ecma_raise_type_error (ECMA_ERR_MSG ("'this' value is not an object."));
+  }
+
+  ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
+
+  ecma_value_t result = ecma_op_object_get_by_magic_id (object_p, LIT_MAGIC_STRING_SOURCE);
+  if (ECMA_IS_VALUE_ERROR (result))
+  {
+    return result;
+  }
+
+  ecma_string_t *source_p = ecma_op_to_string (result);
+  ecma_free_value (result);
+
+  if (source_p == NULL)
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  result = ecma_op_object_get_by_magic_id (object_p, LIT_MAGIC_STRING_FLAGS);
+  if (ECMA_IS_VALUE_ERROR (result))
+  {
+    ecma_deref_ecma_string (source_p);
+    return result;
+  }
+
+  ecma_string_t *flags_p = ecma_op_to_string (result);
+  ecma_free_value (result);
+
+  if (flags_p == NULL)
+  {
+    ecma_deref_ecma_string (source_p);
+    return ECMA_VALUE_ERROR;
+  }
+
+  ecma_stringbuilder_t builder = ecma_stringbuilder_create ();
+  ecma_stringbuilder_append_byte (&builder, LIT_CHAR_SLASH);
+  ecma_stringbuilder_append (&builder, source_p);
+  ecma_stringbuilder_append_byte (&builder, LIT_CHAR_SLASH);
+  ecma_stringbuilder_append (&builder, flags_p);
+
+  ecma_deref_ecma_string (source_p);
+  ecma_deref_ecma_string (flags_p);
+
+  return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
+#else /* !ENABLED (JERRY_ES2015) */
+  if (!ecma_object_is_regexp_object (this_arg))
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("'this' value is not a RegExp object."));
   }
 
   ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
@@ -469,8 +583,90 @@ ecma_builtin_regexp_prototype_to_string (ecma_value_t this_arg) /**< this argume
   }
 
   return ecma_make_string_value (ecma_stringbuilder_finalize (&result));
+#endif /* ENABLED (JERRY_ES2015) */
 } /* ecma_builtin_regexp_prototype_to_string */
 
+#if ENABLED (JERRY_ES2015)
+/**
+ * Helper function to determine if method is the builtin exec method
+ *
+ * @return true, if function is the builtin exec method
+ *         false, otherwise
+ */
+inline bool JERRY_ATTR_ALWAYS_INLINE
+ecma_builtin_is_regexp_exec (ecma_extended_object_t *obj_p)
+{
+  return (ecma_get_object_is_builtin ((ecma_object_t *) obj_p)
+          && obj_p->u.built_in.routine_id == ECMA_ROUTINE_LIT_MAGIC_STRING_EXECecma_builtin_regexp_prototype_exec);
+} /* ecma_builtin_is_regexp_exec */
+
+/**
+ * The RegExp.prototype object's '@@replace' routine
+ *
+ * See also:
+ *          ECMA-262 v6.0, 21.2.5.8
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_regexp_prototype_symbol_replace (ecma_value_t this_arg, /**< this argument */
+                                              ecma_value_t string_arg, /**< source string */
+                                              ecma_value_t replace_arg) /**< replace string */
+{
+  return ecma_regexp_replace_helper (this_arg, string_arg, replace_arg);
+} /* ecma_builtin_regexp_prototype_symbol_replace */
+
+/**
+ * The RegExp.prototype object's '@@search' routine
+ *
+ * See also:
+ *          ECMA-262 v6.0, 21.2.5.9
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_regexp_prototype_symbol_search (ecma_value_t this_arg, /**< this argument */
+                                             ecma_value_t string_arg) /**< string argument */
+{
+  return ecma_regexp_search_helper (this_arg, string_arg);
+} /* ecma_builtin_regexp_prototype_symbol_search */
+
+/**
+ * The RegExp.prototype object's '@@split' routine
+ *
+ * See also:
+ *          ECMA-262 v6.0, 21.2.5.11
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_regexp_prototype_symbol_split (ecma_value_t this_arg, /**< this argument */
+                                            ecma_value_t string_arg, /**< source string */
+                                            ecma_value_t limit_arg) /**< limit */
+{
+  return ecma_regexp_split_helper (this_arg, string_arg, limit_arg);
+} /* ecma_builtin_regexp_prototype_symbol_split */
+
+/**
+ * The RegExp.prototype object's '@@match' routine
+ *
+ * See also:
+ *          ECMA-262 v6.0, 21.2.5.6
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_regexp_prototype_symbol_match (ecma_value_t this_arg, /**< this argument */
+                                            ecma_value_t string_arg) /**< source string */
+{
+  return ecma_regexp_match_helper (this_arg, string_arg);
+} /* ecma_builtin_regexp_prototype_symbol_match */
+#endif /* ENABLED (JERRY_ES2015) */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.inc.h

@@ -46,6 +46,19 @@ ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_IGNORECASE_UL,
 ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_MULTILINE,
                     ecma_builtin_regexp_prototype_get_multiline,
                     ECMA_PROPERTY_FIXED)
+
+ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_UNICODE,
+                    ecma_builtin_regexp_prototype_get_unicode,
+                    ECMA_PROPERTY_FIXED)
+
+ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_STICKY,
+                    ecma_builtin_regexp_prototype_get_sticky,
+                    ECMA_PROPERTY_FIXED)
+
+ROUTINE (LIT_GLOBAL_SYMBOL_REPLACE, ecma_builtin_regexp_prototype_symbol_replace, 2, 2)
+ROUTINE (LIT_GLOBAL_SYMBOL_SEARCH, ecma_builtin_regexp_prototype_symbol_search, 1, 1)
+ROUTINE (LIT_GLOBAL_SYMBOL_SPLIT, ecma_builtin_regexp_prototype_symbol_split, 2, 2)
+ROUTINE (LIT_GLOBAL_SYMBOL_MATCH, ecma_builtin_regexp_prototype_symbol_match, 1, 1)
 #else /* !ENABLED (JERRY_ES2015) */
 /* ECMA-262 v5, 15.10.7.1 */
 STRING_VALUE (LIT_MAGIC_STRING_SOURCE,

jerry-core/ecma/builtin-objects/ecma-builtin-regexp.c

@@ -66,6 +66,10 @@ ecma_builtin_regexp_dispatch_construct (const ecma_value_t *arguments_list_p, /*
 {
   ecma_value_t pattern_value = ECMA_VALUE_UNDEFINED;
   ecma_value_t flags_value = ECMA_VALUE_UNDEFINED;
+#if ENABLED (JERRY_ES2015)
+  ecma_value_t new_pattern = ECMA_VALUE_EMPTY;
+  ecma_value_t new_flags = ECMA_VALUE_EMPTY;
+#endif /* ENABLED (JERRY_ES2015) */
 
   if (arguments_list_len > 0)
   {
@@ -78,54 +82,112 @@ ecma_builtin_regexp_dispatch_construct (const ecma_value_t *arguments_list_p, /*
     }
   }
 
-  if (ecma_is_value_object (pattern_value)
-      && ecma_object_class_is (ecma_get_object_from_value (pattern_value), LIT_MAGIC_STRING_REGEXP_UL))
+#if ENABLED (JERRY_ES2015)
+  ecma_value_t regexp_value = ecma_op_is_regexp (pattern_value);
+
+  if (ECMA_IS_VALUE_ERROR (regexp_value))
   {
+    return regexp_value;
+  }
+
+  bool is_regexp = regexp_value == ECMA_VALUE_TRUE;
+#else /* !ENABLED (JERRY_ES2015) */
+  bool is_regexp = ecma_object_is_regexp_object (pattern_value);
+#endif /* ENABLED (JERRY_ES2015) */
+
+  if (is_regexp)
+  {
+#if ENABLED (JERRY_ES2015)
+    ecma_object_t *pattern_obj_p = ecma_get_object_from_value (pattern_value);
+
+    new_pattern = ecma_op_object_get_by_magic_id (pattern_obj_p, LIT_MAGIC_STRING_SOURCE);
+
+    if (ECMA_IS_VALUE_ERROR (new_pattern))
+    {
+      return new_pattern;
+    }
+
+    pattern_value = new_pattern;
+
+    if (ecma_is_value_undefined (flags_value))
+    {
+      new_flags = ecma_op_object_get_by_magic_id (pattern_obj_p, LIT_MAGIC_STRING_FLAGS);
+
+      if (ECMA_IS_VALUE_ERROR (new_flags))
+      {
+        ecma_free_value (new_pattern);
+        return new_flags;
+      }
+
+      flags_value = new_flags;
+    }
+#else /* !ENABLED (JERRY_ES2015) */
     if (ecma_is_value_undefined (flags_value))
     {
       return ecma_copy_value (pattern_value);
     }
 
     return ecma_raise_type_error (ECMA_ERR_MSG ("Invalid argument of RegExp call."));
+#endif /* ENABLED (JERRY_ES2015) */
   }
 
-  ecma_string_t *pattern_string_p = NULL;
-  ecma_value_t ret_value = ecma_regexp_read_pattern_str_helper (pattern_value, &pattern_string_p);
-  if (ECMA_IS_VALUE_ERROR (ret_value))
+  ecma_string_t *pattern_string_p = ecma_regexp_read_pattern_str_helper (pattern_value);
+  ecma_value_t ret_value = ECMA_VALUE_ERROR;
+
+  if (pattern_string_p == NULL)
   {
-    return ret_value;
+    goto cleanup;
   }
-  JERRY_ASSERT (ecma_is_value_empty (ret_value));
 
   uint16_t flags = 0;
+
   if (!ecma_is_value_undefined (flags_value))
   {
-    ecma_value_t flags_str_value = ecma_op_to_string (flags_value);
+    ecma_string_t *flags_string_p = ecma_op_to_string (flags_value);
 
-    if (ECMA_IS_VALUE_ERROR (flags_str_value))
+    if (JERRY_UNLIKELY (flags_string_p == NULL))
     {
       ecma_deref_ecma_string (pattern_string_p);
-      return flags_str_value;
+      goto cleanup;
     }
 
-    ecma_string_t *flags_string_p = ecma_get_string_from_value (flags_str_value);
-    JERRY_ASSERT (flags_string_p != NULL);
     ret_value = ecma_regexp_parse_flags (flags_string_p, &flags);
-    ecma_free_value (flags_str_value); // implicit frees flags_string_p
+    ecma_deref_ecma_string (flags_string_p);
 
     if (ECMA_IS_VALUE_ERROR (ret_value))
     {
       ecma_deref_ecma_string (pattern_string_p);
-      return ret_value;
+      goto cleanup;
     }
     JERRY_ASSERT (ecma_is_value_empty (ret_value));
   }
 
   ret_value = ecma_op_create_regexp_object (pattern_string_p, flags);
   ecma_deref_ecma_string (pattern_string_p);
+
+cleanup:
+#if ENABLED (JERRY_ES2015)
+  ecma_free_value (new_pattern);
+  ecma_free_value (new_flags);
+#endif /* ENABLED (JERRY_ES2015) */
+
   return ret_value;
 } /* ecma_builtin_regexp_dispatch_construct */
 
+#if ENABLED (JERRY_ES2015)
+/**
+ * 21.2.4.2 get RegExp [ @@species ] accessor
+ *
+ * @return ecma_value
+ *         returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_builtin_regexp_species_get (ecma_value_t this_value) /**< This Value */
+{
+  return ecma_copy_value (this_value);
+} /* ecma_builtin_regexp_species_get */
+#endif /* ENABLED (JERRY_ES2015) */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-regexp.inc.h

@@ -31,6 +31,13 @@ OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
               ECMA_BUILTIN_ID_REGEXP_PROTOTYPE,
               ECMA_PROPERTY_FIXED)
 
+#if ENABLED (JERRY_ES2015)
+/* ECMA-262 v6, 21.2.4.2 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES,
+                    ecma_builtin_regexp_species_get,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+#endif /* ENABLED (JERRY_ES2015) */
+
 #endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-set-iterator-prototype.c

@@ -19,10 +19,6 @@
 
 #if ENABLED (JERRY_ES2015_BUILTIN_SET)
 
-#if !ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
-#error "Set iterator builtin requires ES2015 iterator builtin"
-#endif /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
-
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"
 

jerry-core/ecma/builtin-objects/ecma-builtin-set-prototype.c

@@ -130,7 +130,8 @@ ecma_builtin_set_prototype_object_size_getter (ecma_value_t this_arg) /**< this
   return ecma_op_container_size (this_arg, LIT_MAGIC_STRING_SET_UL);
 } /* ecma_builtin_set_prototype_object_size_getter */
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
+
 /**
  * The Set.prototype object's 'entries' routine
  *
@@ -188,7 +189,7 @@ ecma_builtin_set_prototype_object_values (ecma_value_t this_arg) /**< this argum
                                             ECMA_PSEUDO_SET_ITERATOR);
 } /* ecma_builtin_set_prototype_object_values */
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /**
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-set-prototype.inc.h

@@ -29,12 +29,12 @@ OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR,
               ECMA_BUILTIN_ID_SET,
               ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
 
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 /* ECMA-262 v6, 23.1.3.13 */
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_SET_UL,
               ECMA_PROPERTY_FLAG_CONFIGURABLE)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 /* Routine properties:
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
@@ -43,12 +43,12 @@ ROUTINE (LIT_MAGIC_STRING_CLEAR, ecma_builtin_set_prototype_object_clear, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_DELETE, ecma_builtin_set_prototype_object_delete, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_FOR_EACH_UL, ecma_builtin_set_prototype_object_foreach, 2, 1)
 ROUTINE (LIT_MAGIC_STRING_HAS, ecma_builtin_set_prototype_object_has, 1, 1)
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_ENTRIES, ecma_builtin_set_prototype_object_entries, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_VALUES, ecma_builtin_set_prototype_object_values, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_KEYS, ecma_builtin_set_prototype_object_keys, 0, 0)
 ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ecma_builtin_set_prototype_object_values, 0, 0)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_SIZE,
                     ecma_builtin_set_prototype_object_size_getter,

jerry-core/ecma/builtin-objects/ecma-builtin-set.c

@@ -65,6 +65,18 @@ ecma_builtin_set_dispatch_construct (const ecma_value_t *arguments_list_p, /**<
                                    ECMA_BUILTIN_ID_SET_PROTOTYPE);
 } /* ecma_builtin_set_dispatch_construct */
 
+/**
+ * 23.2.2.2 get Set [ @@species ] accessor
+ *
+ * @return ecma_value
+ *         returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_builtin_set_species_get (ecma_value_t this_value) /**< This Value */
+{
+  return ecma_copy_value (this_value);
+} /* ecma_builtin_set_species_get */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/ecma-builtin-set.inc.h

@@ -42,6 +42,11 @@ OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE,
               ECMA_BUILTIN_ID_SET_PROTOTYPE,
               ECMA_PROPERTY_FIXED)
 
+/* ECMA-262 v6, 23.2.2.2 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES,
+                    ecma_builtin_set_species_get,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_SET) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-string-iterator-prototype.c

@@ -17,11 +17,7 @@
 #include "ecma-builtins.h"
 #include "ecma-iterator-object.h"
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
-
-#if !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
-#error "Iterator builtin requires ES2015 symbol builtin"
-#endif /* !ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#if ENABLED (JERRY_ES2015)
 
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"
@@ -81,7 +77,6 @@ ecma_builtin_string_iterator_prototype_object_next (ecma_value_t this_val) /**<
 
   JERRY_ASSERT (ecma_is_value_string (iterated_value));
 
-
   ecma_string_t *string_p = ecma_get_string_from_value (iterated_value);
 
   /* 6. */
@@ -149,4 +144,4 @@ ecma_builtin_string_iterator_prototype_object_next (ecma_value_t this_val) /**<
  * @}
  */
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */

jerry-core/ecma/builtin-objects/ecma-builtin-string-iterator-prototype.inc.h

@@ -19,7 +19,7 @@
 
 #include "ecma-builtin-helpers-macro-defines.inc.h"
 
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+#if ENABLED (JERRY_ES2015)
 
 STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
               LIT_MAGIC_STRING_STRING_ITERATOR_UL,
@@ -29,6 +29,6 @@ STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
  *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
 ROUTINE (LIT_MAGIC_STRING_NEXT, ecma_builtin_string_iterator_prototype_object_next, 0, 0)
 
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.inc.h

@@ -67,16 +67,14 @@ ROUTINE (LIT_MAGIC_STRING_TRIM, ECMA_STRING_PROTOTYPE_TRIM, 0, 0)
 ROUTINE (LIT_MAGIC_STRING_SUBSTR, ECMA_STRING_PROTOTYPE_SUBSTR, 2, 2)
 #endif /* ENABLED (JERRY_BUILTIN_ANNEXB) */
 
-#if ENABLED (JERRY_ES2015_BUILTIN)
+#if ENABLED (JERRY_ES2015)
 ROUTINE (LIT_MAGIC_STRING_REPEAT, ECMA_STRING_PROTOTYPE_REPEAT, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_STARTS_WITH, ECMA_STRING_PROTOTYPE_STARTS_WITH, 2, 1)
 ROUTINE (LIT_MAGIC_STRING_INCLUDES, ECMA_STRING_PROTOTYPE_INCLUDES, 2, 1)
 ROUTINE (LIT_MAGIC_STRING_ENDS_WITH, ECMA_STRING_PROTOTYPE_ENDS_WITH, 2, 1)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN) */
-
-#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+ROUTINE (LIT_MAGIC_STRING_CODE_POINT_AT, ECMA_STRING_PROTOTYPE_CODE_POINT_AT, 1, 1)
 ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ECMA_STRING_PROTOTYPE_ITERATOR, 0, 0)
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+#endif /* ENABLED (JERRY_ES2015) */
 
 #endif /* ENABLED (JERRY_BUILTIN_STRING) */
 

jerry-core/ecma/builtin-objects/ecma-builtin-string.c

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include "lit-strings.h"
 #include "ecma-alloc.h"
 #include "ecma-builtins.h"
 #include "ecma-conversion.h"
@@ -22,9 +23,9 @@
 #include "ecma-helpers.h"
 #include "ecma-objects.h"
 #include "ecma-string-object.h"
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
 #include "ecma-symbol-object.h"
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
 #include "ecma-try-catch-macro.h"
 #include "jrt.h"
 
@@ -109,6 +110,230 @@ ecma_builtin_string_object_from_char_code (ecma_value_t this_arg, /**< 'this' ar
   return ret_value;
 } /* ecma_builtin_string_object_from_char_code */
 
+#if ENABLED (JERRY_ES2015)
+
+/**
+ * The String object's 'raw' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 21.1.2.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_string_object_raw (ecma_value_t this_arg, /**< 'this' argument */
+                                const ecma_value_t args[], /**< arguments list */
+                                ecma_length_t args_number) /**< number of arguments */
+{
+  JERRY_UNUSED (this_arg);
+
+  /* 1 - 2. */
+  const ecma_value_t *substitutions;
+  ecma_length_t number_of_substitutions;
+
+  if (args_number > 1)
+  {
+    substitutions = args + 1;
+    number_of_substitutions = args_number - 1;
+  }
+  else
+  {
+    substitutions = NULL;
+    number_of_substitutions = 0;
+  }
+
+  /* 3. */
+  ecma_value_t template = args_number > 0 ? args[0] : ECMA_VALUE_UNDEFINED;
+
+  ecma_value_t cooked = ecma_op_to_object (template);
+
+  /* 4. */
+  if (ECMA_IS_VALUE_ERROR (cooked))
+  {
+    return cooked;
+  }
+
+  ecma_object_t *cooked_obj_p = ecma_get_object_from_value (cooked);
+
+  /* 5. */
+  ecma_value_t raw = ecma_op_object_get_by_magic_id (cooked_obj_p, LIT_MAGIC_STRING_RAW);
+
+  ecma_deref_object (cooked_obj_p);
+
+  if (ECMA_IS_VALUE_ERROR (raw))
+  {
+    return raw;
+  }
+
+  ecma_value_t raw_obj = ecma_op_to_object (raw);
+
+  /* 6. */
+  if (ECMA_IS_VALUE_ERROR (raw_obj))
+  {
+    ecma_free_value (raw);
+    return raw_obj;
+  }
+
+  ecma_object_t *raw_obj_p = ecma_get_object_from_value (raw_obj);
+
+  ecma_value_t ret_value = ECMA_VALUE_ERROR;
+
+  /* 7 - 8. */
+  uint32_t literal_segments;
+  if (ECMA_IS_VALUE_ERROR (ecma_op_object_get_length (raw_obj_p, &literal_segments)))
+  {
+    goto cleanup;
+  }
+
+  /* 9. */
+  if (literal_segments == 0)
+  {
+    ret_value = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
+    goto cleanup;
+  }
+
+  /* 10. */
+  ecma_stringbuilder_t builder = ecma_stringbuilder_create ();
+
+  /* 11. */
+  uint32_t next_index = 0;
+
+  /* 12. */
+  while (true)
+  {
+    /* 12.a,b */
+    ecma_value_t next_seg = ecma_op_object_get_by_uint32_index (raw_obj_p, next_index);
+
+    if (ECMA_IS_VALUE_ERROR (next_seg))
+    {
+      goto builder_cleanup;
+    }
+
+    ecma_string_t *next_seg_srt_p = ecma_op_to_string (next_seg);
+
+    /* 12.c */
+    if (JERRY_UNLIKELY (next_seg_srt_p == NULL))
+    {
+      ecma_free_value (next_seg);
+      goto builder_cleanup;
+    }
+
+    /* 12.d */
+    ecma_stringbuilder_append (&builder, next_seg_srt_p);
+
+    ecma_deref_ecma_string (next_seg_srt_p);
+    ecma_free_value (next_seg);
+
+    /* 12.e */
+    if (next_index + 1 == literal_segments)
+    {
+      ret_value = ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
+      goto cleanup;
+    }
+
+    /* 12.f-g */
+    if (next_index >= number_of_substitutions)
+    {
+      continue;
+    }
+
+    /* 12.h */
+    ecma_string_t *next_sub_p = ecma_op_to_string (substitutions[next_index]);
+
+    /* 12.i */
+    if (JERRY_UNLIKELY (next_sub_p == NULL))
+    {
+      goto builder_cleanup;
+    }
+
+    /* 12.j */
+    ecma_stringbuilder_append (&builder, next_sub_p);
+    ecma_deref_ecma_string (next_sub_p);
+
+    /* 12.k */
+    next_index++;
+  }
+
+builder_cleanup:
+  ecma_stringbuilder_destroy (&builder);
+
+cleanup:
+  ecma_deref_object (raw_obj_p);
+  ecma_free_value (raw);
+
+  return ret_value;
+} /* ecma_builtin_string_object_raw */
+
+/**
+ * The String object's 'fromCodePoint' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 21.1.2.2
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_string_object_from_code_point (ecma_value_t this_arg, /**< 'this' argument */
+                                            const ecma_value_t args[], /**< arguments list */
+                                            ecma_length_t args_number) /**< number of arguments */
+{
+  JERRY_UNUSED (this_arg);
+
+  if (args_number == 0)
+  {
+    return ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
+  }
+
+  ecma_stringbuilder_t builder = ecma_stringbuilder_create ();
+
+  for (ecma_length_t index = 0; index < args_number; index++)
+  {
+    ecma_value_t to_number_value = ecma_op_to_number (args[index]);
+
+    if (ECMA_IS_VALUE_ERROR (to_number_value))
+    {
+      ecma_stringbuilder_destroy (&builder);
+      return to_number_value;
+    }
+
+    ecma_number_t to_number_num = ecma_get_number_from_value (to_number_value);
+    ecma_free_value (to_number_value);
+
+    ecma_number_t to_int_num;
+    ecma_value_t to_int_value = ecma_op_to_integer (to_number_value, &to_int_num);
+
+    if (ECMA_IS_VALUE_ERROR (to_int_value))
+    {
+      ecma_stringbuilder_destroy (&builder);
+      return to_int_value;
+    }
+
+    if (to_number_num != to_int_num || to_int_num < 0 || to_int_num > LIT_UNICODE_CODE_POINT_MAX)
+    {
+      ecma_stringbuilder_destroy (&builder);
+      return ecma_raise_range_error (ECMA_ERR_MSG ("Error: Invalid code point"));
+    }
+
+    lit_code_point_t code_point = (uint32_t) to_int_num;
+
+    ecma_char_t converted_cp[2];
+    uint8_t encoded_size = lit_utf16_encode_code_point (code_point, converted_cp);
+
+    for (uint8_t i = 0; i < encoded_size; i++)
+    {
+      ecma_stringbuilder_append_char (&builder, converted_cp[i]);
+    }
+  }
+
+  ecma_string_t *ret_str_p = ecma_stringbuilder_finalize (&builder);
+
+  return ecma_make_string_value (ret_str_p);
+} /* ecma_builtin_string_object_from_code_point */
+
+#endif /* ENABLED (JERRY_ES2015) */
+
 /**
  * Handle calling [[Call]] of built-in String object
  *
@@ -130,17 +355,23 @@ ecma_builtin_string_dispatch_call (const ecma_value_t *arguments_list_p, /**< ar
   {
     ret_value = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
   }
-#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
+#if ENABLED (JERRY_ES2015)
   /* 2.a */
   else if (ecma_is_value_symbol (arguments_list_p[0]))
   {
     ret_value = ecma_get_symbol_descriptive_string (arguments_list_p[0]);
   }
-#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
+#endif /* ENABLED (JERRY_ES2015) */
   /* 2.b */
   else
   {
-    ret_value = ecma_op_to_string (arguments_list_p[0]);
+    ecma_string_t *str_p = ecma_op_to_string (arguments_list_p[0]);
+    if (JERRY_UNLIKELY (str_p == NULL))
+    {
+      return ECMA_VALUE_ERROR;
+    }
+
+    ret_value = ecma_make_string_value (str_p);
   }
 
   return ret_value;