Rework the core of class parsing/runtime semantic

Changes:
 - Use the pre-scanner to provide information for the parser about the existence of the class constructor
 - The allocation of the super declarative environment is no longer needed
 - The VM frame context holds the information about the this binding status
 - Reduce the number of class related VM/CBC instructions
 - Improve ecma_op_function_{construct, call} to property set new.target

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

Author: rerobika

jerry-core/api/jerry.c

@@ -2769,7 +2769,7 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
     JERRY_ASSERT (jerry_value_is_constructor (func_obj_val));
 
     return jerry_return (ecma_op_function_construct (ecma_get_object_from_value (func_obj_val),
-                                                     ECMA_VALUE_UNDEFINED,
+                                                     ecma_get_object_from_value (func_obj_val),
                                                      args_p,
                                                      args_count));
   }

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

@@ -111,15 +111,13 @@ typedef enum
   ECMA_PARSE_EVAL = (1u << 2), /**< eval is called */
   ECMA_PARSE_DIRECT_EVAL = (1u << 3), /**< eval is called directly (ECMA-262 v5, 15.1.2.1.1) */
 
-  /* These four status flags must be in this order. See PARSER_CLASS_PARSE_OPTS_OFFSET. */
+  /* These two status flags must be in this order. See PARSER_CLASS_PARSE_OPTS_OFFSET. */
   ECMA_PARSE_CLASS_CONSTRUCTOR = (1u << 4), /**< a class constructor is being parsed (this value must be kept in
                                              *   in sync with PARSER_CLASS_CONSTRUCTOR) */
-  ECMA_PARSE_HAS_SUPER = (1u << 5), /**< the current context has super reference */
-  ECMA_PARSE_HAS_IMPL_SUPER = (1u << 6), /**< the current context has implicit parent class */
-  ECMA_PARSE_HAS_STATIC_SUPER = (1u << 7), /**< the current context is a static class method */
+  ECMA_PARSE_CLASS_HERITAGE = (1u << 5), /**< the current method is in a heritage context */
 
-  ECMA_PARSE_CALLED_FROM_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_CALLED_FROM_FUNCTION = (1u << 6), /**< a function body is parsed or the code is inside a function */
+  ECMA_PARSE_GENERATOR_FUNCTION = (1u << 7), /**< generator function is parsed */
 
   /* These flags are internally used by the parser. */
 } ecma_parse_opts_t;
@@ -195,7 +193,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_CONSTRUCTOR = ECMA_MAKE_VALUE (9), /**< special value for bound class constructors */
+  ECMA_VALUE_CLASS_ENVIRONMENT = ECMA_MAKE_VALUE (9), /**< a special value for class encironment record on the stack */
   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 */
@@ -661,12 +659,12 @@ 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_HOME_OBJECT_BOUND = 15, /**< object-bound lexical environment
+                                                     *  with provided home object reference */
 
   ECMA_LEXICAL_ENVIRONMENT_TYPE_START = ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE, /**< first lexical
                                                                                *   environment type */
-  ECMA_LEXICAL_ENVIRONMENT_TYPE__MAX = ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND /**< maximum value */
+  ECMA_LEXICAL_ENVIRONMENT_TYPE__MAX = ECMA_LEXICAL_ENVIRONMENT_HOME_OBJECT_BOUND /**< maximum value */
 } ecma_lexical_environment_type_t;
 
 #if ENABLED (JERRY_ES2015)
@@ -778,8 +776,9 @@ typedef struct
   union
   {
     jmem_cpointer_t property_list_cp; /**< compressed pointer to object's
-                                       *  or declerative lexical environments's property list */
+                                       *   or declerative lexical environments's property list */
     jmem_cpointer_t bound_object_cp;  /**< compressed pointer to lexical environments's the bound object */
+    jmem_cpointer_t home_object_cp;  /**< compressed pointer to lexical environments's the home object */
   } u1;
 
   /** object prototype or outer reference */
@@ -953,13 +952,12 @@ typedef struct
 #endif /* ENABLED (JERRY_SNAPSHOT_EXEC) */
 
 #if ENABLED (JERRY_ES2015)
-
 /**
  * Description of arrow function objects.
  */
 typedef struct
 {
-  ecma_extended_object_t header; /**< extended object header */
+  ecma_extended_object_t header; /**< object header */
   ecma_value_t this_binding; /**< value of 'this' binding */
 } ecma_arrow_function_t;
 
@@ -1862,6 +1860,32 @@ typedef struct
   ecma_extended_object_t header; /**< header part */
   ecma_value_t proxy; /**< [[RevocableProxy]] internal slot */
 } ecma_revocable_proxy_object_t;
+
+/**
+ * Set "derived" [[ConstructorKind]] flag for the [[Construct]] method.
+ *
+ * Whenever this flag is set the new_target_p parameter contains the current [[ThisBindingValue]]
+ *
+ * @param new_target_p new.target to invoke the [[Construct]] with
+ */
+#define ECMA_SET_DERIVED_FLAG(new_target_p) \
+  ((ecma_object_t *) (((uintptr_t) (new_target_p)) | (uintptr_t) 0x01))
+
+/**
+ * Check whether the "derived" [[ConstructorKind]] flag is set
+ *
+ * @param new_target_p new.target which the [[Construct]] was invoked
+ */
+#define ECMA_HAS_DERIVED_FLAG(new_target_p) (((uintptr_t) (new_target_p)) & (uintptr_t) 0x1)
+
+/**
+ * Clear the "derived" [[ConstructorKind]] flag from the parameter
+ *
+ * @param new_target_p new.target which the [[Construct]] was invoked
+ */
+#define ECMA_CLEAR_DERIVED_FLAG(new_target_p) \
+  ((ecma_object_t *) (((uintptr_t) (new_target_p)) & ((uintptr_t) ~0x01)))
+
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_PROXY) */
 
 /**

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

@@ -144,6 +144,45 @@ ecma_collection_push_back (ecma_collection_t *collection_p, /**< value collectio
   collection_p->buffer_p = buffer_p;
 } /* ecma_collection_push_back */
 
+/**
+ * Reserve space for the given amount of ecma_values in the collection
+ */
+void
+ecma_collection_reserve (ecma_collection_t *collection_p, /**< value collection */
+                         uint32_t count) /**< number of ecma values to reserve */
+{
+  JERRY_ASSERT (collection_p != NULL);
+  JERRY_ASSERT (UINT32_MAX - count > collection_p->capacity);
+
+  const uint32_t new_capacity = collection_p->capacity + count;
+  const uint32_t old_size = ECMA_COLLECTION_ALLOCATED_SIZE (collection_p->capacity);
+  const uint32_t new_size = ECMA_COLLECTION_ALLOCATED_SIZE (new_capacity);
+
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+  buffer_p = jmem_heap_realloc_block (buffer_p, old_size, new_size);
+
+  collection_p->capacity = new_capacity;
+  collection_p->buffer_p = buffer_p;
+} /* ecma_collection_reserve */
+
+/**
+ * Append a list of values to the end of the collection
+ */
+void
+ecma_collection_append (ecma_collection_t *collection_p, /**< value collection */
+                        const ecma_value_t *buffer_p, /**< values to append */
+                        uint32_t count) /**< number of ecma values to append */
+{
+  JERRY_ASSERT (collection_p != NULL);
+  if (collection_p->capacity - collection_p->item_count > count)
+  {
+    ecma_collection_reserve (collection_p, count);
+  }
+
+  memcpy (collection_p->buffer_p + collection_p->item_count, buffer_p, count * sizeof (ecma_value_t));
+  collection_p->item_count += count;
+} /* ecma_collection_append */
+
 /**
  * @}
  * @}

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

@@ -141,7 +141,7 @@ ecma_create_object_lex_env (ecma_object_t *outer_lexical_environment_p, /**< out
 {
 #if ENABLED (JERRY_ES2015)
   JERRY_ASSERT (type == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND
-                || type == ECMA_LEXICAL_ENVIRONMENT_SUPER_OBJECT_BOUND);
+                || type == ECMA_LEXICAL_ENVIRONMENT_HOME_OBJECT_BOUND);
 #else /* !ENABLED (JERRY_ES2015) */
   JERRY_ASSERT (type == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND);
 #endif /* ENABLED (JERRY_ES2015) */
@@ -288,7 +288,7 @@ ecma_get_lex_env_binding_object (const ecma_object_t *object_p) /**< object-boun
   JERRY_ASSERT (ecma_is_lexical_environment (object_p));
 #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);
+                || ecma_get_lex_env_type (object_p) == ECMA_LEXICAL_ENVIRONMENT_HOME_OBJECT_BOUND);
 #else /* !ENABLED (JERRY_ES2015) */
   JERRY_ASSERT (ecma_get_lex_env_type (object_p) == ECMA_LEXICAL_ENVIRONMENT_THIS_OBJECT_BOUND);
 #endif /* ENABLED (JERRY_ES2015) */

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

@@ -402,6 +402,8 @@ lit_utf8_size_t ecma_number_to_binary_floating_point_number (ecma_number_t num,
 /* ecma-helpers-collection.c */
 ecma_collection_t *ecma_new_collection (void);
 void ecma_collection_push_back (ecma_collection_t *collection_p, ecma_value_t value);
+void ecma_collection_reserve (ecma_collection_t *collection_p, uint32_t count);
+void ecma_collection_append (ecma_collection_t *collection_p, const ecma_value_t *buffer_p, uint32_t count);
 void ecma_collection_destroy (ecma_collection_t *collection_p);
 void ecma_collection_free (ecma_collection_t *collection_p);
 void ecma_collection_free_if_not_object (ecma_collection_t *collection_p);
@@ -419,7 +421,6 @@ bool JERRY_ATTR_PURE ecma_get_object_is_builtin (const ecma_object_t *object_p);
 void ecma_set_object_is_builtin (ecma_object_t *object_p);
 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);
 

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

@@ -128,7 +128,7 @@ ecma_builtin_array_object_from (ecma_value_t this_arg, /**< 'this' argument */
     {
       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);
+      array = ecma_op_function_construct (constructor_obj_p, constructor_obj_p, NULL, 0);
 
       if (ecma_is_value_undefined (array) || ecma_is_value_null (array))
       {
@@ -289,7 +289,7 @@ ecma_builtin_array_object_from (ecma_value_t this_arg, /**< 'this' argument */
   {
     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);
+    array = ecma_op_function_construct (constructor_obj_p, constructor_obj_p, &len_value, 1);
 
     if (ecma_is_value_undefined (array) || ecma_is_value_null (array))
     {
@@ -414,7 +414,7 @@ ecma_builtin_array_object_of (ecma_value_t this_arg, /**< 'this' argument */
   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,
+                                                     ecma_get_object_from_value (this_arg),
                                                      &len,
                                                      1);
 

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

@@ -205,10 +205,8 @@ ecma_builtin_reflect_dispatch_routine (uint16_t builtin_routine_id, /**< built-i
       return ECMA_VALUE_ERROR;
     }
 
-    // TODO: add new_target_p to construct when it'll be supported
-    JERRY_UNUSED (new_target_p);
     ecma_value_t ret_value = ecma_op_function_construct (target_p,
-                                                         ECMA_VALUE_UNDEFINED,
+                                                         new_target_p,
                                                          coll_p->buffer_p,
                                                          coll_p->item_count);
 

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

@@ -733,7 +733,7 @@ ecma_op_array_species_create (ecma_object_t *original_array_p, /**< The object f
   ecma_value_t len_val = ecma_make_uint32_value (length);
   ecma_object_t *ctor_object_p = ecma_get_object_from_value (constructor);
   ecma_value_t ret_val = ecma_op_function_construct (ctor_object_p,
-                                                     ECMA_VALUE_UNDEFINED,
+                                                     ctor_object_p,
                                                      &len_val,
                                                      1);