1 files changed, 85 insertions, 27 deletions

diff --git a/Source/JavaScriptCore/parser/ParserError.h b/Source/JavaScriptCore/parser/ParserError.h
index baa4465d0..7883efed2 100644
--- a/Source/JavaScriptCore/parser/ParserError.h
+++ b/Source/JavaScriptCore/parser/ParserError.h
@@ -23,17 +23,18 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef ParserError_h
-#define ParserError_h
+#pragma once
 
 #include "Error.h"
+#include "ErrorHandlingScope.h"
 #include "ExceptionHelpers.h"
 #include "ParserTokens.h"
 #include <wtf/text/WTFString.h>
 
 namespace JSC {
 
-struct ParserError {
+class ParserError {
+public:
     enum SyntaxErrorType {
         SyntaxErrorNone,
         SyntaxErrorIrrecoverable,
@@ -49,62 +50,119 @@ struct ParserError {
         SyntaxError
     };
 
-    ErrorType m_type;
-    SyntaxErrorType m_syntaxErrorType;
-    JSToken m_token;
-    String m_message;
-    int m_line;
     ParserError()
         : m_type(ErrorNone)
         , m_syntaxErrorType(SyntaxErrorNone)
-        , m_line(-1)
     {
     }
     
     explicit ParserError(ErrorType type)
         : m_type(type)
         , m_syntaxErrorType(SyntaxErrorNone)
-        , m_line(-1)
     {
     }
 
     ParserError(ErrorType type, SyntaxErrorType syntaxError, JSToken token)
-        : m_type(type)
+        : m_token(token)
+        , m_type(type)
         , m_syntaxErrorType(syntaxError)
-        , m_token(token)
-        , m_line(-1)
     {
     }
 
-    ParserError(ErrorType type, SyntaxErrorType syntaxError, JSToken token, String msg, int line)
-        : m_type(type)
-        , m_syntaxErrorType(syntaxError)
-        , m_token(token)
+    ParserError(ErrorType type, SyntaxErrorType syntaxError, JSToken token, const String& msg, int line)
+        : m_token(token)
         , m_message(msg)
         , m_line(line)
+        , m_type(type)
+        , m_syntaxErrorType(syntaxError)
     {
     }
 
-    JSObject* toErrorObject(JSGlobalObject* globalObject, const SourceCode& source)
+    bool isValid() const { return m_type != ErrorNone; }
+    SyntaxErrorType syntaxErrorType() const { return m_syntaxErrorType; }
+    const JSToken& token() const { return m_token; }
+    const String& message() const { return m_message; }
+    int line() const { return m_line; }
+
+    JSObject* toErrorObject(
+        JSGlobalObject* globalObject, const SourceCode& source, 
+        int overrideLineNumber = -1)
     {
+        ExecState* exec = globalObject->globalExec();
         switch (m_type) {
         case ErrorNone:
-            return 0;
+            return nullptr;
         case SyntaxError:
-            return addErrorInfo(globalObject->globalExec(), createSyntaxError(globalObject, m_message), m_line, source);
+            return addErrorInfo(
+                exec, 
+                createSyntaxError(exec, m_message), 
+                overrideLineNumber == -1 ? m_line : overrideLineNumber, source);
         case EvalError:
-            return createSyntaxError(globalObject, m_message);
-        case StackOverflow:
-            return createStackOverflowError(globalObject);
+            return createSyntaxError(exec, m_message);
+        case StackOverflow: {
+            ErrorHandlingScope errorScope(globalObject->vm());
+            return createStackOverflowError(exec);
+        }
         case OutOfMemory:
-            return createOutOfMemoryError(globalObject);
+            return createOutOfMemoryError(exec);
         }
         CRASH();
-        return createOutOfMemoryError(globalObject); // Appease Qt bot
+        return nullptr;
     }
-#undef GET_ERROR_CODE
+
+private:
+    JSToken m_token;
+    String m_message;
+    int m_line { -1 };
+    ErrorType m_type;
+    SyntaxErrorType m_syntaxErrorType;
 };
 
 } // namespace JSC
 
-#endif // ParserError_h
+namespace WTF {
+
+inline void printInternal(PrintStream& out, JSC::ParserError::SyntaxErrorType type)
+{
+    switch (type) {
+    case JSC::ParserError::SyntaxErrorNone:
+        out.print("SyntaxErrorNone");
+        return;
+    case JSC::ParserError::SyntaxErrorIrrecoverable:
+        out.print("SyntaxErrorIrrecoverable");
+        return;
+    case JSC::ParserError::SyntaxErrorUnterminatedLiteral:
+        out.print("SyntaxErrorUnterminatedLiteral");
+        return;
+    case JSC::ParserError::SyntaxErrorRecoverable:
+        out.print("SyntaxErrorRecoverable");
+        return;
+    }
+    
+    RELEASE_ASSERT_NOT_REACHED();
+}
+
+inline void printInternal(PrintStream& out, JSC::ParserError::ErrorType type)
+{
+    switch (type) {
+    case JSC::ParserError::ErrorNone:
+        out.print("ErrorNone");
+        return;
+    case JSC::ParserError::StackOverflow:
+        out.print("StackOverflow");
+        return;
+    case JSC::ParserError::EvalError:
+        out.print("EvalError");
+        return;
+    case JSC::ParserError::OutOfMemory:
+        out.print("OutOfMemory");
+        return;
+    case JSC::ParserError::SyntaxError:
+        out.print("SyntaxError");
+        return;
+    }
+    
+    RELEASE_ASSERT_NOT_REACHED();
+}
+
+} // namespace WTF