Implement ES2015 class feature (part II.)

This patch is the second milestone of the implementation of this new language element.

Supported:
 - Single class inheritance
 - Functionality of 'super' keyword
 - Implicit constructor in class heritage
 - Specific behaviour while extending with the built-in 'Array' or '%TypedArray%' object
 - Abstract subclasses (Mix-ins)

JerryScript-DCO-1.0-Signed-off-by: Robert Fancsik [email protected]

Author: rerobika

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

@@ -76,18 +76,25 @@ typedef enum
   ECMA_TYPE_DIRECT_STRING = 5, /**< directly encoded string values */
   ECMA_TYPE_ERROR = 7, /**< pointer to description of an error reference (only supported by C API) */
   ECMA_TYPE_POINTER = ECMA_TYPE_ERROR, /**< a generic aligned pointer */
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+  ECMA_TYPE_CLASS = ECMA_TYPE_ERROR, /**< special type for class contextes */
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
   ECMA_TYPE_SNAPSHOT_OFFSET = ECMA_TYPE_ERROR, /**< offset to a snapshot number/string */
   ECMA_TYPE___MAX = ECMA_TYPE_ERROR /** highest value for ecma types */
 } ecma_type_t;
 
 /**
  * Option flags for script parsing.
+ * NOTE: The enum members must be kept in sync with parser_general_flags_t
  */
 typedef enum
 {
   ECMA_PARSE_NO_OPTS = 0, /**< no options passed */
-  ECMA_PARSE_STRICT_MODE = (1 << 0), /**< enable strict mode */
-  ECMA_PARSE_DIRECT_EVAL = (1 << 1) /**< is eval called directly (ECMA-262 v5, 15.1.2.1.1) */
+  ECMA_PARSE_STRICT_MODE = (1u << 0), /**< enable strict mode */
+  ECMA_PARSE_DIRECT_EVAL = (1u << 1), /**< is eval called directly (ECMA-262 v5, 15.1.2.1.1) */
+  ECMA_PARSE_CLASS_CONSTRUCTOR = (1u << 2), /**< a class constructor is being parsed */
+  ECMA_PARSE_HAS_SUPER = (1u << 3), /**< the current context has super reference */
+  ECMA_PARSE_HAS_STATIC_SUPER = (1u << 4), /**< the current context is a static class method */
 } ecma_parse_opts_t;
 
 /**
@@ -170,6 +177,7 @@ enum
                                                *   ecma_op_object_find */
   ECMA_VALUE_REGISTER_REF = ECMA_MAKE_VALUE (8), /**< register reference,
                                                   *   a special "base" value for vm */
+  ECMA_VALUE_IMPLICIT_CALL = ECMA_MAKE_VALUE (9), /**< special value for implicit constructor call */
 };
 
 #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
@@ -633,12 +641,42 @@ typedef enum
   ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE = 13, /**< declarative lexical environment */
   ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND = 14, /**< object-bound lexical environment
                                                     *   with provideThis flag */
+  ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND = 15, /**< object-bound lexical environment
+                                                     *   with provided super reference */
 
   ECMA_LEXICAL_ENVIRONMENT_TYPE_START = ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE, /**< first lexical
-                                                                               *    environment type */
-  ECMA_LEXICAL_ENVIRONMENT_TYPE__MAX = ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND /**< maximum value */
+                                                                               *   environment type */
+  ECMA_LEXICAL_ENVIRONMENT_TYPE__MAX = ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND /**< maximum value */
 } ecma_lexical_environment_type_t;
 
+/**
+ * Offset for JERRY_CONTEXT (status_flags) top 8 bits.
+ */
+#define ECMA_SUPER_EVAL_OPTS_OFFSET (32 - 8)
+
+/**
+ * Set JERRY_CONTEXT (status_flags) top 8 bits to the specified 'opts'.
+ */
+#define ECMA_SET_SUPER_EVAL_PARSER_OPTS(opts) \
+  do \
+  { \
+    JERRY_CONTEXT (status_flags) |= ((uint32_t) opts << ECMA_SUPER_EVAL_OPTS_OFFSET) | ECMA_STATUS_DIRECT_EVAL; \
+  } while (0)
+
+/**
+ * Get JERRY_CONTEXT (status_flags) top 8 bits.
+ */
+#define ECMA_GET_SUPER_EVAL_PARSER_OPTS() (JERRY_CONTEXT (status_flags) >> ECMA_SUPER_EVAL_OPTS_OFFSET)
+
+/**
+ * Clear JERRY_CONTEXT (status_flags) top 8 bits.
+ */
+#define ECMA_CLEAR_SUPER_EVAL_PARSER_OPTS() \
+  do \
+  { \
+    JERRY_CONTEXT (status_flags) &= ((1 << ECMA_SUPER_EVAL_OPTS_OFFSET) - 1); \
+  } while (0)
+
 /**
  * Ecma object type mask for getting the object type.
  */
@@ -656,6 +694,11 @@ typedef enum
  */
 #define ECMA_OBJECT_FLAG_EXTENSIBLE 0x20
 
+/**
+ * Represents whether the 'super(...)' has been called.
+ */
+#define ECMA_HERITAGE_SUPER_CALLED ECMA_OBJECT_FLAG_EXTENSIBLE
+
 /**
  * Value for increasing or decreasing the object reference counter.
  */

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

@@ -122,6 +122,25 @@ ecma_is_value_direct (ecma_value_t value) /**< ecma value */
   return (ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT);
 } /* ecma_is_value_direct */
 
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+/**
+ * Check if the value is class result ecma-value.
+ *
+ * @return true - if the value is a class result value,
+ *         false - otherwise
+ */
+inline bool JERRY_ATTR_CONST JERRY_ATTR_ALWAYS_INLINE
+ecma_is_value_class (ecma_value_t value) /**< ecma value */
+{
+  if (ECMA_IS_VALUE_ERROR (value))
+  {
+    return false;
+  }
+
+  return (ecma_get_value_type_field (value) == ECMA_TYPE_CLASS);
+} /* ecma_is_value_class */
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
+
 /**
  * Check if the value is simple ecma-value.
  *
@@ -744,8 +763,14 @@ ecma_copy_value (ecma_value_t value)  /**< value description */
     }
     default:
     {
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+      JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT
+                    || ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT_STRING
+                    || ecma_get_value_type_field (value) == ECMA_TYPE_CLASS);
+#else /* CONFIG_DISABLE_ES2015_CLASS */
       JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT
                     || ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT_STRING);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
 
       return value;
     }
@@ -936,8 +961,14 @@ ecma_free_value (ecma_value_t value) /**< value description */
 
     default:
     {
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+      JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT
+                    || ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT_STRING
+                    || ecma_get_value_type_field (value) == ECMA_TYPE_CLASS);
+#else /* CONFIG_DISABLE_ES2015_CLASS */
       JERRY_ASSERT (ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT
                     || ecma_get_value_type_field (value) == ECMA_TYPE_DIRECT_STRING);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
 
       /* no memory is allocated */
       break;

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

@@ -127,7 +127,7 @@ ecma_create_decl_lex_env (ecma_object_t *outer_lexical_environment_p) /**< outer
 
 /**
  * Create a object lexical environment with specified outer lexical environment
- * (or NULL if the environment is not nested), binding object and provideThis flag.
+ * (or NULL if the environment is not nested), binding object and provided type flag.
  *
  * See also: ECMA-262 v5, 10.2.1.2
  *
@@ -137,16 +137,17 @@ ecma_create_decl_lex_env (ecma_object_t *outer_lexical_environment_p) /**< outer
  */
 ecma_object_t *
 ecma_create_object_lex_env (ecma_object_t *outer_lexical_environment_p, /**< outer lexical environment */
-                            ecma_object_t *binding_obj_p) /**< binding object */
+                            ecma_object_t *binding_obj_p, /**< binding object */
+                            ecma_lexical_environment_type_t type) /**< type of the new lexical environment */
 {
+  JERRY_ASSERT (type == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND
+                || type == ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND);
   JERRY_ASSERT (binding_obj_p != NULL
                 && !ecma_is_lexical_environment (binding_obj_p));
 
   ecma_object_t *new_lexical_environment_p = ecma_alloc_object ();
 
-  uint16_t type = ECMA_OBJECT_FLAG_BUILT_IN_OR_LEXICAL_ENV | ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND;
-
-  new_lexical_environment_p->type_flags_refs = type;
+  new_lexical_environment_p->type_flags_refs = (uint16_t) (ECMA_OBJECT_FLAG_BUILT_IN_OR_LEXICAL_ENV | type);
 
   ecma_init_gc_info (new_lexical_environment_p);
 
@@ -355,7 +356,8 @@ 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));
-  JERRY_ASSERT (ecma_get_lex_env_type (object_p) == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND);
+  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);
 
   return ECMA_GET_NON_NULL_POINTER (ecma_object_t,
                                     object_p->property_list_or_bound_object_cp);

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

@@ -148,6 +148,9 @@ bool JERRY_ATTR_CONST ecma_is_value_true (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_false (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_found (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_is_value_array_hole (ecma_value_t value);
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+bool JERRY_ATTR_CONST ecma_is_value_class (ecma_value_t value);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
 
 bool JERRY_ATTR_CONST ecma_is_value_integer_number (ecma_value_t value);
 bool JERRY_ATTR_CONST ecma_are_values_integer_numbers (ecma_value_t first_value, ecma_value_t second_value);
@@ -293,7 +296,8 @@ ecma_collection_iterator_next (ecma_value_t *iterator_p);
 /* ecma-helpers.c */
 ecma_object_t *ecma_create_object (ecma_object_t *prototype_object_p, size_t ext_object_size, ecma_object_type_t type);
 ecma_object_t *ecma_create_decl_lex_env (ecma_object_t *outer_lexical_environment_p);
-ecma_object_t *ecma_create_object_lex_env (ecma_object_t *outer_lexical_environment_p, ecma_object_t *binding_obj_p);
+ecma_object_t *ecma_create_object_lex_env (ecma_object_t *outer_lexical_environment_p, ecma_object_t *binding_obj_p,
+                                           ecma_lexical_environment_type_t type);
 bool JERRY_ATTR_PURE ecma_is_lexical_environment (const ecma_object_t *object_p);
 bool JERRY_ATTR_PURE ecma_get_object_extensible (const ecma_object_t *object_p);
 void ecma_set_object_extensible (ecma_object_t *object_p, bool is_extensible);

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

@@ -223,7 +223,18 @@ ecma_builtin_array_prototype_object_concat (ecma_value_t this_arg, /**< this arg
                   ret_value);
 
   /* 2. */
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+  ecma_object_t *obj_p = ecma_get_object_from_value (obj_this);
+  ecma_value_t new_array = ecma_op_create_array_object_by_constructor (0, 0, false, obj_p);
+
+  if (ECMA_IS_VALUE_ERROR (new_array))
+  {
+    ecma_free_value (obj_this);
+    return new_array;
+  }
+#else /* CONFIG_DISABLE_ES2015_CLASS */
   ecma_value_t new_array = ecma_op_create_array_object (0, 0, false);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
   ecma_object_t *new_array_p = ecma_get_object_from_value (new_array);
   uint32_t new_length = 0;
 
@@ -825,7 +836,19 @@ ecma_builtin_array_prototype_object_slice (ecma_value_t this_arg, /**< 'this' ar
 
   JERRY_ASSERT (start <= len && end <= len);
 
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+  ecma_value_t new_array = ecma_op_create_array_object_by_constructor (0, 0, false, obj_p);
+
+  if (ECMA_IS_VALUE_ERROR (new_array))
+  {
+    ecma_free_value (len_value);
+    ecma_free_value (obj_this);
+    return new_array;
+  }
+#else /* CONFIG_DISABLE_ES2015_CLASS */
   ecma_value_t new_array = ecma_op_create_array_object (0, 0, false);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
+
   ecma_object_t *new_array_p = ecma_get_object_from_value (new_array);
 
   /* 9. */
@@ -1973,7 +1996,19 @@ ecma_builtin_array_prototype_object_map (ecma_value_t this_arg, /**< this argume
     /* 5. arg2 is simply used as T */
 
     /* 6. */
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+    ecma_value_t new_array = ecma_op_create_array_object_by_constructor (NULL, 0, false, obj_p);
+
+    if (ECMA_IS_VALUE_ERROR (new_array))
+    {
+      ecma_free_value (len_value);
+      ecma_free_value (obj_this);
+      return new_array;
+    }
+#else /* CONFIG_DISABLE_ES2015_CLASS */
     ecma_value_t new_array = ecma_op_create_array_object (NULL, 0, false);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
+
     JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (new_array));
     ecma_object_t *new_array_p = ecma_get_object_from_value (new_array);
 
@@ -2080,7 +2115,18 @@ ecma_builtin_array_prototype_object_filter (ecma_value_t this_arg, /**< this arg
     ecma_object_t *func_object_p;
 
     /* 6. */
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+    ecma_value_t new_array = ecma_op_create_array_object_by_constructor (NULL, 0, false, obj_p);
+
+    if (ECMA_IS_VALUE_ERROR (new_array))
+    {
+      ecma_free_value (len_value);
+      ecma_free_value (obj_this);
+      return new_array;
+    }
+#else /* CONFIG_DISABLE_ES2015_CLASS */
     ecma_value_t new_array = ecma_op_create_array_object (NULL, 0, false);
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
     JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (new_array));
     ecma_object_t *new_array_p = ecma_get_object_from_value (new_array);
 

jerry-core/ecma/operations/ecma-array-object.c

@@ -24,6 +24,9 @@
 #include "ecma-number-arithmetic.h"
 #include "ecma-objects.h"
 #include "ecma-objects-general.h"
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+#include "ecma-function-object.h"
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
 
 /** \addtogroup ecma ECMA
  * @{
@@ -43,14 +46,14 @@
  */
 ecma_value_t
 ecma_op_create_array_object (const ecma_value_t *arguments_list_p, /**< list of arguments that
-                                                                        are passed to Array constructor */
+                                                                    *   are passed to Array constructor */
                              ecma_length_t arguments_list_len, /**< length of the arguments' list */
                              bool is_treat_single_arg_as_length) /**< if the value is true,
-                                                                      arguments_list_len is 1
-                                                                      and single argument is Number,
-                                                                      then treat the single argument
-                                                                      as new Array's length rather
-                                                                      than as single item of the Array */
+                                                                  *   arguments_list_len is 1
+                                                                  *   and single argument is Number,
+                                                                  *   then treat the single argument
+                                                                  *   as new Array's length rather
+                                                                  *   than as single item of the Array */
 {
   JERRY_ASSERT (arguments_list_len == 0
                 || arguments_list_p != NULL);
@@ -131,6 +134,67 @@ ecma_op_create_array_object (const ecma_value_t *arguments_list_p, /**< list of
   return ecma_make_object_value (object_p);
 } /* ecma_op_create_array_object */
 
+#ifndef CONFIG_DISABLE_ES2015_CLASS
+/**
+ * Array object creation operation according to the 'constructor' property.
+ *
+ * See also: ECMA-262 v6, 9.4.2.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_op_create_array_object_by_constructor (const ecma_value_t *arguments_list_p, /**< list of arguments that
+                                                                                   *   are passed to
+                                                                                   *   Array constructor */
+                                            ecma_length_t arguments_list_len, /**< length of the arguments' list */
+                                            bool is_treat_single_arg_as_length, /**< if the value is true,
+                                                                                 *   arguments_list_len is 1
+                                                                                 *   and single argument is Number,
+                                                                                 *   then treat the single argument
+                                                                                 *   as new Array's length rather
+                                                                                 *   than as single item of the
+                                                                                 *   Array */
+                                            ecma_object_t *object_p) /**< The object from whom the new array object
+                                                                      *   is being created */
+{
+  ecma_value_t constructor_value = ecma_op_object_get_by_magic_id (object_p, LIT_MAGIC_STRING_CONSTRUCTOR);
+
+  if (ECMA_IS_VALUE_ERROR (constructor_value)
+      || !ecma_is_value_object (constructor_value)
+      || !ecma_is_constructor (constructor_value))
+  {
+    ecma_free_value (constructor_value);
+    return ecma_raise_type_error (ECMA_ERR_MSG ("object.constructor is not a constructor."));
+  }
+
+  ecma_object_t *constructor_object_p = ecma_get_object_from_value (constructor_value);
+  ecma_value_t constructor_prototype = ecma_op_object_get_by_magic_id (constructor_object_p,
+                                                                       LIT_MAGIC_STRING_PROTOTYPE);
+  if (ECMA_IS_VALUE_ERROR (constructor_prototype))
+  {
+    ecma_deref_object (constructor_object_p);
+    return constructor_prototype;
+  }
+
+  ecma_value_t result = ecma_op_create_array_object (arguments_list_p,
+                                                     arguments_list_len,
+                                                     is_treat_single_arg_as_length);
+
+  if (ecma_is_value_object (constructor_prototype))
+  {
+    ecma_object_t *result_object_p = ecma_get_object_from_value (result);
+    ecma_object_t *constructor_prototpye_object_p = ecma_get_object_from_value (constructor_prototype);
+    ECMA_SET_POINTER (result_object_p->prototype_or_outer_reference_cp, constructor_prototpye_object_p);
+  }
+
+  ecma_free_value (constructor_prototype);
+  ecma_deref_object (constructor_object_p);
+
+  return result;
+} /* ecma_op_create_array_object_by_constructor */
+#endif /* !CONFIG_DISABLE_ES2015_CLASS */
+
 /**
  * Update the length of an array to a new length
  *

jerry-core/ecma/operations/ecma-array-object.h

@@ -43,6 +43,10 @@ ecma_value_t
 ecma_op_create_array_object (const ecma_value_t *arguments_list_p, ecma_length_t arguments_list_len,
                              bool is_treat_single_arg_as_length);
 
+ecma_value_t
+ecma_op_create_array_object_by_constructor (const ecma_value_t *arguments_list_p, ecma_length_t arguments_list_len,
+                                            bool is_treat_single_arg_as_length, ecma_object_t *object_p);
+
 ecma_value_t
 ecma_op_array_object_set_length (ecma_object_t *object_p, ecma_value_t new_value, uint32_t flags);