Make the assert a built-in method.

Remove the assert intrinsic from the parser and instead
make it a real built-in method. This allows us to redefine
the method if needed during runtime from JS.

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

Author: galpeter

jerry-core/ecma/base/ecma-magic-strings.inc.h

@@ -13,6 +13,19 @@
  * limitations under the License.
  */
 
+/*
+ * Naming convention for the magic strings.
+ *
+ * If the magic string has a format of:
+ * - ECMA_MAGIC_STRING_[identifier][^_CHAR|_U|_UL] then the value is a lower-cased "identifier".
+ * - ECMA_MAGIC_STRING_[identifier]_U then the value is an upper-cased "identifier".
+ * - ECMA_MAGIC_STRING_[identifier]_UL then the value is an "identifier" with
+        mixed upper-case and lower-case characters.
+ * - ECMA_MAGIC_STRING_[identifier]_CHAR then the value is a character.
+ * - ECMA_MAGIC_STRING__[identifier] then the value is a string described by identifier,
+ *      but could not be described using other cases.
+ */
+
 /*
  * List of ECMA magic strings
  */
@@ -212,4 +225,6 @@ ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING__EMPTY, "")
 /*
  * Implementation-defined magic strings
  */
+ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_ASSERT, "assert")
+ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING__ASSERTION_FAILED, "Assertion failed")
 ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_JERRY_UL, "Jerry")

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

@@ -16,6 +16,7 @@
 #include "ecma-alloc.h"
 #include "ecma-builtins.h"
 #include "ecma-conversion.h"
+#include "ecma-exceptions.h"
 #include "ecma-gc.h"
 #include "ecma-globals.h"
 #include "ecma-helpers.h"
@@ -208,6 +209,69 @@ ecma_builtin_global_object_encode_uri_component (ecma_value_t this_arg, /**< thi
   ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, uri_component);
 } /* ecma_builtin_global_object_encode_uri_component */
 
+/**
+ * Engine internal method to raise an Error for asserts.
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_assert (ecma_value_t this_arg __attr_unused___, /**< this argument */
+                                   ecma_value_t condition, /**< assert condition */
+                                   ecma_value_t message) /** < optional assert message*/
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_TRY_CATCH (boolean_value,
+                  ecma_op_to_boolean (condition),
+                  ret_value);
+
+  if (ecma_is_value_true (boolean_value))
+  {
+    ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
+  }
+  else
+  {
+    ecma_string_t *assert_failed_str_p = NULL;
+
+    if (ecma_is_value_undefined (message) || ecma_is_value_object (message))
+    {
+      /*
+       * In case of object we just ignore it and use our default string.
+       * This is to avoid side effects caused by objects:
+       * If we call the ecma_op_to_string on an object then it will try to invoke
+       * the toString property which could lead to strange results.
+       */
+      assert_failed_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING__ASSERTION_FAILED);
+    }
+    else
+    {
+      ECMA_TRY_CATCH (message_value,
+                      ecma_op_to_string (message),
+                      ret_value);
+
+      assert_failed_str_p = ecma_copy_or_ref_ecma_string (ecma_get_string_from_value (message_value));
+
+      ECMA_FINALIZE (message_value);
+
+      /*
+       * In this case the ecma_op_to_string should only be called on primitive types (not on object).
+       * This there `ret_value` will be always empty, but just to be sure we'll do an assert on it.
+       */
+      JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
+    }
+
+    ecma_object_t *error = ecma_new_standard_error_with_message (ECMA_ERROR_COMMON, assert_failed_str_p);
+    ret_value = ecma_make_throw_obj_completion_value (error);
+
+    ecma_deref_ecma_string (assert_failed_str_p);
+  }
+
+  ECMA_FINALIZE (boolean_value);
+
+  return ret_value;
+} /* ecma_builtin_global_object_assert */
+
 /**
  * @}
  * @}

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

@@ -232,6 +232,9 @@ ROUTINE (ECMA_MAGIC_STRING_ENCODE_URI, ecma_builtin_global_object_encode_uri, 1,
 ROUTINE (ECMA_MAGIC_STRING_ENCODE_URI_COMPONENT, ecma_builtin_global_object_encode_uri_component, 1, 1)
 ROUTINE (ECMA_MAGIC_STRING_PARSE_INT, ecma_builtin_global_object_parse_int, 2, 2)
 
+/* Not part of ECMA 262 but used for testing */
+ROUTINE (ECMA_MAGIC_STRING_ASSERT, ecma_builtin_global_object_assert, 2, 2)
+
 #undef OBJECT_ID
 #undef SIMPLE_VALUE
 #undef NUMBER_VALUE

jerry-core/ecma/operations/ecma-function-object.cpp

@@ -942,7 +942,8 @@ ecma_op_function_declaration (ecma_object_t *lex_env_p, /**< lexical environment
   }
   else
   {
-    JERRY_ASSERT (ecma_is_completion_value_empty (completion));
+    JERRY_ASSERT (ecma_is_completion_value_empty (completion)
+                  || ecma_is_completion_value_normal_simple_value (completion, ECMA_SIMPLE_VALUE_TRUE));
 
     // f.
     ret_value = ecma_op_set_mutable_binding (lex_env_p,

jerry-core/parser/js/opcodes-dumper.cpp

@@ -386,28 +386,6 @@ create_op_meta_for_vlt (varg_list_type vlt, operand *res, operand *obj)
   return ret;
 }
 
-static void
-dump_assert (operand op)
-{
-  switch (op.type)
-  {
-    case OPERAND_LITERAL:
-    {
-      const opcode_t opcode = getop_is_true_jmp_down (LITERAL_TO_REWRITE, 0, 2);
-      serializer_dump_op_meta (create_op_meta_100 (opcode, op.data.lit_id));
-      break;
-    }
-    case OPERAND_TMP:
-    {
-      const opcode_t opcode = getop_is_true_jmp_down (op.data.uid, 0, 2);
-      serializer_dump_op_meta (create_op_meta_000 (opcode));
-      break;
-    }
-  }
-  const opcode_t opcode = getop_exitval (1);
-  serializer_dump_op_meta (create_op_meta_000 (opcode));
-}
-
 static void
 split_opcode_counter (opcode_counter_t oc, idx_t *id1, idx_t *id2)
 {
@@ -729,25 +707,15 @@ dumper_finish_scope (void)
 }
 
 bool
-dumper_is_intrinsic (operand obj)
+dumper_is_intrinsic (operand /* obj */)
 {
-  if (obj.type == OPERAND_LITERAL)
-  {
-    if (literal_equal_type_s (lexer_get_literal_by_id (obj.data.lit_id), "assert"))
-    {
-      return true;
-    }
-  }
   return false;
 }
 
 operand
-dump_intrinsic (operand obj, operand arg)
+dump_intrinsic (operand /* obj */, operand /* arg */)
 {
-  JERRY_ASSERT (obj.type == OPERAND_LITERAL);
-  TODO (/* Rewrite when there will be more intrinsics.  */)
-  JERRY_ASSERT (literal_equal_type_s (lexer_get_literal_by_id (obj.data.lit_id), "assert"));
-  dump_assert (arg);
+  JERRY_UNREACHABLE ();
   return dump_undefined_assignment_res ();
 }
 

main-linux.cpp

@@ -132,7 +132,7 @@ main (int argc,
   jerry_flag_t flags = JERRY_FLAG_EMPTY;
 
 #ifdef JERRY_ENABLE_LOG
-  const char *log_file_name = nullptr;
+  const char *log_file_name = NULL;
 #endif /* JERRY_ENABLE_LOG */
   for (i = 1; i < argc; i++)
   {
@@ -222,7 +222,7 @@ main (int argc,
       if (log_file_name)
       {
         jerry_log_file = fopen (log_file_name, "w");
-        if (jerry_log_file == nullptr)
+        if (jerry_log_file == NULL)
         {
           JERRY_ERROR_MSG ("Failed to open log file: %s\n", log_file_name);
           return JERRY_STANDALONE_EXIT_CODE_FAIL;
@@ -259,7 +259,7 @@ main (int argc,
       if (jerry_log_file && jerry_log_file != stdout)
       {
         fclose (jerry_log_file);
-        jerry_log_file = nullptr;
+        jerry_log_file = NULL;
       }
 #endif /* JERRY_ENABLE_LOG */