From 0d742557c6e314263fe775fc1057c990d6eb1fd7 Mon Sep 17 00:00:00 2001
From: Ali Mohammad Pur <ali.mpfard@gmail.com>
Date: Thu, 29 Apr 2021 06:58:46 +0430
Subject: [PATCH] Shell: Allow Syntax errors to be mutated while parsing

Some nodes (such as heredocs) cannot be validated immediately, so the
entire tree will need to be revalidated if we don't allow mutating
syntax errors.
---
 Userland/Shell/AST.cpp | 22 ++++++++++++++++++++--
 Userland/Shell/AST.h   | 32 +++++++++++++++++++++-----------
 2 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/Userland/Shell/AST.cpp b/Userland/Shell/AST.cpp
index e66566039b..49902f5a10 100644
--- a/Userland/Shell/AST.cpp
+++ b/Userland/Shell/AST.cpp
@@ -248,6 +248,25 @@ static Vector<String> resolve_slices(RefPtr<Shell> shell, Vector<String>&& value
     return move(values);
 }
 
+void Node::clear_syntax_error()
+{
+    m_syntax_error_node->clear_syntax_error();
+}
+
+void Node::set_is_syntax_error(const SyntaxError& error_node)
+{
+    if (!m_syntax_error_node) {
+        m_syntax_error_node = error_node;
+    } else {
+        m_syntax_error_node->set_is_syntax_error(error_node);
+    }
+}
+
+bool Node::is_syntax_error() const
+{
+    return m_syntax_error_node && m_syntax_error_node->is_syntax_error();
+}
+
 void Node::for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(NonnullRefPtr<Value>)> callback)
 {
     auto value = run(shell)->resolve_without_cast(shell);
@@ -1884,7 +1903,7 @@ ImmediateExpression::ImmediateExpression(Position position, NameWithPosition fun
     , m_function(move(function))
     , m_closing_brace_position(move(closing_brace_position))
 {
-    if (m_is_syntax_error)
+    if (is_syntax_error())
         return;
 
     for (auto& argument : m_arguments) {
@@ -3021,7 +3040,6 @@ SyntaxError::SyntaxError(Position position, String error, bool is_continuable)
     , m_syntax_error_text(move(error))
     , m_is_continuable(is_continuable)
 {
-    m_is_syntax_error = true;
 }
 
 const SyntaxError& SyntaxError::syntax_error_node() const
diff --git a/Userland/Shell/AST.h b/Userland/Shell/AST.h
index 69be321f10..28ff0dac64 100644
--- a/Userland/Shell/AST.h
+++ b/Userland/Shell/AST.h
@@ -407,6 +407,9 @@ private:
 };
 
 class Node : public RefCounted<Node> {
+    AK_MAKE_NONCOPYABLE(Node);
+    AK_MAKE_NONMOVABLE(Node);
+
 public:
     virtual void dump(int level) const = 0;
     virtual void for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(NonnullRefPtr<Value>)> callback);
@@ -431,20 +434,15 @@ public:
     virtual bool is_tilde() const { return false; }
     virtual bool is_variable_decls() const { return false; }
     virtual bool is_simple_variable() const { return false; }
-    virtual bool is_syntax_error() const { return m_is_syntax_error; }
+    virtual bool is_syntax_error() const;
 
     virtual bool is_list() const { return false; }
     virtual bool would_execute() const { return false; }
     virtual bool should_override_execution_in_current_process() const { return false; }
 
     const Position& position() const { return m_position; }
-    void set_is_syntax_error(const SyntaxError& error_node)
-    {
-        if (!m_is_syntax_error) {
-            m_is_syntax_error = true;
-            m_syntax_error_node = error_node;
-        }
-    }
+    virtual void clear_syntax_error();
+    virtual void set_is_syntax_error(const SyntaxError& error_node);
     virtual const SyntaxError& syntax_error_node() const
     {
         VERIFY(is_syntax_error());
@@ -508,8 +506,7 @@ public:
 
 protected:
     Position m_position;
-    bool m_is_syntax_error { false };
-    RefPtr<const SyntaxError> m_syntax_error_node;
+    RefPtr<SyntaxError> m_syntax_error_node;
 };
 
 #define NODE(name)                                               \
@@ -1363,17 +1360,30 @@ public:
     const String& error_text() const { return m_syntax_error_text; }
     bool is_continuable() const { return m_is_continuable; }
 
+    virtual void clear_syntax_error() override
+    {
+        m_is_cleared = true;
+    }
+    virtual void set_is_syntax_error(const SyntaxError& error) override
+    {
+        m_is_cleared = error.m_is_cleared;
+        m_is_continuable = error.m_is_continuable;
+        m_syntax_error_text = error.error_text();
+    }
+
+    virtual bool is_syntax_error() const override { return !m_is_cleared; }
+
 private:
     NODE(SyntaxError);
     virtual void dump(int level) const override;
     virtual RefPtr<Value> run(RefPtr<Shell>) override;
     virtual void highlight_in_editor(Line::Editor&, Shell&, HighlightMetadata = {}) override;
     virtual HitTestResult hit_test_position(size_t) const override { return { nullptr, nullptr, nullptr }; }
-    virtual bool is_syntax_error() const override { return true; }
     virtual const SyntaxError& syntax_error_node() const override;
 
     String m_syntax_error_text;
     bool m_is_continuable { false };
+    bool m_is_cleared { false };
 };
 
 class SyntheticNode final : public Node {