LibJS: Implement LabelledStatement & LabelledEvaluation semantics

Instead of slapping 0..N labels on a statement like the current
LabelableStatement does, we need the spec's LabelledStatement for a
proper implementation of control flow using only completions - it always
has one label and one labelled statement - what appears to be 'multiple
labels' on the same statement is actually nested LabelledStatements.

Note that this is unused yet and will fully replace LabelableStatement
in the next commit.

Userland/Libraries/LibJS/AST.cpp

@@ -66,6 +66,11 @@ String ASTNode::class_name() const
  return demangle(typeid(*this).name()).substring(4);
 }
 
+static void print_indent(int indent)
+{
+ out("{}", String::repeated(' ', indent * 2));
+}
+
 static void update_function_name(Value value, FlyString const& name)
 {
  if (!value.is_function())
@@ -104,6 +109,110 @@ Completion ScopeNode::evaluate_statements(Interpreter& interpreter, GlobalObject
  return completion;
 }
 
+// 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
+// BreakableStatement : IterationStatement
+static Completion labelled_evaluation(Interpreter& interpreter, GlobalObject& global_object, IterationStatement const& statement, Vector<FlyString> const& label_set)
+{
+ // 1. Let stmtResult be LoopEvaluation of IterationStatement with argument labelSet.
+ auto result = statement.loop_evaluation(interpreter, global_object, label_set);
+
+ // 2. If stmtResult.[[Type]] is break, then
+ if (result.type() == Completion::Type::Break) {
+ // a. If stmtResult.[[Target]] is empty, then
+ if (!result.target().has_value()) {
+ // i. If stmtResult.[[Value]] is empty, set stmtResult to NormalCompletion(undefined).
+ // ii. Else, set stmtResult to NormalCompletion(stmtResult.[[Value]]).
+ result = normal_completion(result.value().value_or(js_undefined()));
+ }
+ }
+
+ // 3. Return Completion(stmtResult).
+ return result;
+}
+
+// 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
+// BreakableStatement : SwitchStatement
+static Completion labelled_evaluation(Interpreter& interpreter, GlobalObject& global_object, SwitchStatement const& statement, Vector<FlyString> const&)
+{
+ // 1. Let stmtResult be the result of evaluating SwitchStatement.
+ auto result = statement.execute_impl(interpreter, global_object);
+
+ // 2. If stmtResult.[[Type]] is break, then
+ if (result.type() == Completion::Type::Break) {
+ // a. If stmtResult.[[Target]] is empty, then
+ if (!result.target().has_value()) {
+ // i. If stmtResult.[[Value]] is empty, set stmtResult to NormalCompletion(undefined).
+ // ii. Else, set stmtResult to NormalCompletion(stmtResult.[[Value]]).
+ result = normal_completion(result.value().value_or(js_undefined()));
+ }
+ }
+
+ // 3. Return Completion(stmtResult).
+ return result;
+}
+
+// 14.13.4 Runtime Semantics: LabelledEvaluation, https://tc39.es/ecma262/#sec-runtime-semantics-labelledevaluation
+// LabelledStatement : LabelIdentifier : LabelledItem
+static Completion labelled_evaluation(Interpreter& interpreter, GlobalObject& global_object, LabelledStatement const& statement, Vector<FlyString> const& label_set)
+{
+ auto const& labelled_item = *statement.labelled_item();
+
+ // 1. Let label be the StringValue of LabelIdentifier.
+ auto const& label = statement.label();
+
+ // 2. Let newLabelSet be the list-concatenation of labelSet and « label ».
+ // Optimization: Avoid vector copy if possible.
+ Optional<Vector<FlyString>> new_label_set;
+ if (is<IterationStatement>(labelled_item) || is<SwitchStatement>(labelled_item) || is<LabelledStatement>(labelled_item)) {
+ new_label_set = label_set;
+ new_label_set->append(label);
+ }
+
+ // 3. Let stmtResult be LabelledEvaluation of LabelledItem with argument newLabelSet.
+ Completion result;
+ if (is<IterationStatement>(labelled_item))
+ result = labelled_evaluation(interpreter, global_object, static_cast<IterationStatement const&>(labelled_item), *new_label_set);
+ else if (is<SwitchStatement>(labelled_item))
+ result = labelled_evaluation(interpreter, global_object, static_cast<SwitchStatement const&>(labelled_item), *new_label_set);
+ else if (is<LabelledStatement>(labelled_item))
+ result = labelled_evaluation(interpreter, global_object, static_cast<LabelledStatement const&>(labelled_item), *new_label_set);
+ else
+ result = labelled_item.execute(interpreter, global_object);
+
+ // 4. If stmtResult.[[Type]] is break and SameValue(stmtResult.[[Target]], label) is true, then
+ if (result.type() == Completion::Type::Break && result.target() == label) {
+ // a. Set stmtResult to NormalCompletion(stmtResult.[[Value]]).
+ result = normal_completion(result.value());
+ }
+
+ // 5. Return Completion(stmtResult).
+ return result;
+}
+
+// 14.13.3 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-labelled-statements-runtime-semantics-evaluation
+Completion LabelledStatement::execute(Interpreter& interpreter, GlobalObject& global_object) const
+{
+ InterpreterNodeScope node_scope { interpreter, *this };
+
+ // 1. Let newLabelSet be a new empty List.
+ // 2. Return LabelledEvaluation of this LabelledStatement with argument newLabelSet.
+ return labelled_evaluation(interpreter, global_object, *this, {});
+}
+
+void LabelledStatement::dump(int indent) const
+{
+ ASTNode::dump(indent);
+
+ print_indent(indent + 1);
+ outln("(Label)");
+ print_indent(indent + 2);
+ outln("\"{}\"", m_label);
+
+ print_indent(indent + 1);
+ outln("(Labelled item)");
+ m_labelled_item->dump(indent + 2);
+}
+
 // 10.2.1.3 Runtime Semantics: EvaluateBody, https://tc39.es/ecma262/#sec-runtime-semantics-evaluatebody
 Completion FunctionBody::execute(Interpreter& interpreter, GlobalObject& global_object) const
 {
@@ -1764,11 +1873,6 @@ ThrowCompletionOr<Value> ClassDeclaration::binding_class_declaration_evaluation(
  return value;
 }
 
-static void print_indent(int indent)
-{
- out("{}", String::repeated(' ', indent * 2));
-}
-
 void ASTNode::dump(int indent) const
 {
  print_indent(indent);

Userland/Libraries/LibJS/AST.h

@@ -86,6 +86,29 @@ class Statement : public ASTNode {
  }
 };
 
+// 14.13 Labelled Statements, https://tc39.es/ecma262/#sec-labelled-statements
+class LabelledStatement : public Statement {
+public:
+ LabelledStatement(SourceRange source_range, FlyString label, NonnullRefPtr<Statement> labelled_item)
+ : Statement(source_range)
+ , m_label(move(label))
+ , m_labelled_item(move(labelled_item))
+ {
+ }
+
+ virtual Completion execute(Interpreter&, GlobalObject&) const override;
+ virtual void dump(int indent) const override;
+
+ FlyString const& label() const { return m_label; }
+ FlyString& label() { return m_label; }
+ NonnullRefPtr<Statement> const& labelled_item() const { return m_labelled_item; }
+ NonnullRefPtr<Statement>& labelled_item() { return m_labelled_item; }
+
+private:
+ FlyString m_label;
+ NonnullRefPtr<Statement> m_labelled_item;
+};
+
 class LabelableStatement : public Statement {
 public:
  using Statement::Statement;