Reference.cpp 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185
  1. /*
  2. * Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <LibJS/AST.h>
  7. #include <LibJS/Runtime/DeclarativeEnvironment.h>
  8. #include <LibJS/Runtime/Error.h>
  9. #include <LibJS/Runtime/GlobalObject.h>
  10. #include <LibJS/Runtime/Reference.h>
  11. namespace JS {
  12. // 6.2.4.6 PutValue ( V, W ), https://tc39.es/ecma262/#sec-putvalue
  13. void Reference::put_value(GlobalObject& global_object, Value value)
  14. {
  15. auto& vm = global_object.vm();
  16. if (!is_valid_reference()) {
  17. vm.throw_exception<ReferenceError>(global_object, ErrorType::InvalidLeftHandAssignment);
  18. return;
  19. }
  20. if (is_unresolvable()) {
  21. if (m_strict) {
  22. throw_reference_error(global_object);
  23. return;
  24. }
  25. MUST(global_object.set(m_name, value, Object::ShouldThrowExceptions::No));
  26. return;
  27. }
  28. if (is_property_reference()) {
  29. auto* base_obj = m_base_value.to_object(global_object);
  30. if (!base_obj)
  31. return;
  32. auto succeeded_or_error = base_obj->internal_set(m_name, value, get_this_value());
  33. if (succeeded_or_error.is_error())
  34. return;
  35. auto succeeded = succeeded_or_error.release_value();
  36. if (!succeeded && m_strict) {
  37. vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishSetProperty, m_name, m_base_value.to_string_without_side_effects());
  38. return;
  39. }
  40. return;
  41. }
  42. VERIFY(m_base_type == BaseType::Environment);
  43. VERIFY(m_base_environment);
  44. if (m_environment_coordinate.has_value())
  45. static_cast<DeclarativeEnvironment*>(m_base_environment)->set_mutable_binding_direct(global_object, m_environment_coordinate->index, value, m_strict);
  46. else
  47. m_base_environment->set_mutable_binding(global_object, m_name.as_string(), value, m_strict);
  48. }
  49. void Reference::throw_reference_error(GlobalObject& global_object) const
  50. {
  51. auto& vm = global_object.vm();
  52. if (!m_name.is_valid())
  53. vm.throw_exception<ReferenceError>(global_object, ErrorType::ReferenceUnresolvable);
  54. else
  55. vm.throw_exception<ReferenceError>(global_object, ErrorType::UnknownIdentifier, m_name.to_string_or_symbol().to_display_string());
  56. }
  57. // 6.2.4.5 GetValue ( V ), https://tc39.es/ecma262/#sec-getvalue
  58. Value Reference::get_value(GlobalObject& global_object) const
  59. {
  60. if (!is_valid_reference() || is_unresolvable()) {
  61. throw_reference_error(global_object);
  62. return {};
  63. }
  64. if (is_property_reference()) {
  65. auto* base_obj = m_base_value.to_object(global_object);
  66. if (!base_obj)
  67. return {};
  68. return TRY_OR_DISCARD(base_obj->get(m_name));
  69. }
  70. VERIFY(m_base_type == BaseType::Environment);
  71. VERIFY(m_base_environment);
  72. if (m_environment_coordinate.has_value())
  73. return static_cast<DeclarativeEnvironment*>(m_base_environment)->get_binding_value_direct(global_object, m_environment_coordinate->index, m_strict);
  74. return m_base_environment->get_binding_value(global_object, m_name.as_string(), m_strict);
  75. }
  76. // 13.5.1.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-delete-operator-runtime-semantics-evaluation
  77. bool Reference::delete_(GlobalObject& global_object)
  78. {
  79. // 13.5.1.2 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-delete-operator-runtime-semantics-evaluation
  80. // UnaryExpression : delete UnaryExpression
  81. // NOTE: The following steps have already been evaluated by the time we get here:
  82. // 1. Let ref be the result of evaluating UnaryExpression.
  83. // 2. ReturnIfAbrupt(ref).
  84. // 3. If ref is not a Reference Record, return true.
  85. // 4. If IsUnresolvableReference(ref) is true, then
  86. if (is_unresolvable()) {
  87. // a. Assert: ref.[[Strict]] is false.
  88. VERIFY(!m_strict);
  89. // b. Return true.
  90. return true;
  91. }
  92. auto& vm = global_object.vm();
  93. // 5. If IsPropertyReference(ref) is true, then
  94. if (is_property_reference()) {
  95. // a. Assert: ! IsPrivateReference(ref) is false.
  96. // FIXME: We don't have private references yet.
  97. // b. If IsSuperReference(ref) is true, throw a ReferenceError exception.
  98. if (is_super_reference()) {
  99. vm.throw_exception<ReferenceError>(global_object, ErrorType::UnsupportedDeleteSuperProperty);
  100. return {};
  101. }
  102. // c. Let baseObj be ! ToObject(ref.[[Base]]).
  103. auto* base_obj = m_base_value.to_object(global_object);
  104. VERIFY(base_obj);
  105. // d. Let deleteStatus be ? baseObj.[[Delete]](ref.[[ReferencedName]]).
  106. bool delete_status = TRY_OR_DISCARD(base_obj->internal_delete(m_name));
  107. // e. If deleteStatus is false and ref.[[Strict]] is true, throw a TypeError exception.
  108. if (!delete_status && m_strict) {
  109. vm.throw_exception<TypeError>(global_object, ErrorType::ReferenceNullishDeleteProperty, m_name, m_base_value.to_string_without_side_effects());
  110. return {};
  111. }
  112. // f. Return deleteStatus.
  113. return delete_status;
  114. }
  115. // 6. Else,
  116. // a. Let base be ref.[[Base]].
  117. // b. Assert: base is an Environment Record.
  118. VERIFY(m_base_type == BaseType::Environment);
  119. // c. Return ? base.DeleteBinding(ref.[[ReferencedName]]).
  120. return m_base_environment->delete_binding(global_object, m_name.as_string());
  121. }
  122. String Reference::to_string() const
  123. {
  124. StringBuilder builder;
  125. builder.append("Reference { Base=");
  126. switch (m_base_type) {
  127. case BaseType::Unresolvable:
  128. builder.append("Unresolvable");
  129. break;
  130. case BaseType::Environment:
  131. builder.appendff("{}", base_environment().class_name());
  132. break;
  133. case BaseType::Value:
  134. if (m_base_value.is_empty())
  135. builder.append("<empty>");
  136. else
  137. builder.appendff("{}", m_base_value.to_string_without_side_effects());
  138. break;
  139. }
  140. builder.append(", ReferencedName=");
  141. if (!m_name.is_valid())
  142. builder.append("<invalid>");
  143. else if (m_name.is_symbol())
  144. builder.appendff("{}", m_name.as_symbol()->to_string());
  145. else
  146. builder.appendff("{}", m_name.to_string());
  147. builder.appendff(", Strict={}", m_strict);
  148. builder.appendff(", ThisValue=");
  149. if (m_this_value.is_empty())
  150. builder.append("<empty>");
  151. else
  152. builder.appendff("{}", m_this_value.to_string_without_side_effects());
  153. builder.append(" }");
  154. return builder.to_string();
  155. }
  156. }