Further exception work on V8

* Get rid of maybeEmitUncaughtException * Mostly get rid of makeError * Introduce exception hierarchy, change exceptions to shared_ptr * Simplify exception throwing code

Dale Glass committed 3 years ago

Commit 67e7a731 parent c0e62c510 files · +249 −260Browse files

Showing the changes to libraries/script-engine/src/v8/ScriptEngineV8.cpp (1 of 10 files). Show all

Unified · Split

libraries/script-engine/src/v8/ScriptEngineV8.cpp+45−172

     return false;
 }
-// engine-aware JS Error copier and factory
+ScriptValue ScriptEngineV8::makeError(const ScriptValue& _other, const QString& type) {
-V8ScriptValue ScriptEngineV8::makeError(const V8ScriptValue& _other, const QString& type) {
     if (!IS_THREADSAFE_INVOCATION(thread(), __FUNCTION__)) {
-        v8::Locker locker(_v8Isolate);
+        return nullValue();
-        v8::Isolate::Scope isolateScope(_v8Isolate);
-        v8::HandleScope handleScope(_v8Isolate);
-        v8::Context::Scope contextScope(getContext());
-        return V8ScriptValue(this, v8::Null(_v8Isolate));
     }
     v8::Locker locker(_v8Isolate);
     v8::Isolate::Scope isolateScope(_v8Isolate);
     v8::HandleScope handleScope(_v8Isolate);
     v8::Context::Scope contextScope(getContext());
-    return V8ScriptValue(this, v8::Null(_v8Isolate));
+    return nullValue();
+}
     //V8TODO
     /*
     auto other = _other;
         err.setProperty(it.name(), it.value());
     }
     return err;*/
-}
+//}
-ScriptValue ScriptEngineV8::makeError(const ScriptValue& _other, const QString& type) {
-    if (!IS_THREADSAFE_INVOCATION(thread(), __FUNCTION__)) {
-        return nullValue();
-    }
-    v8::Locker locker(_v8Isolate);
-    v8::Isolate::Scope isolateScope(_v8Isolate);
-    v8::HandleScope handleScope(_v8Isolate);
-    v8::Context::Scope contextScope(getContext());
-    return nullValue();
-    //V8TODO
-    //what does makeError actually do?
-    /*ScriptValueV8Wrapper* unwrapped = ScriptValueV8Wrapper::unwrap(_other);
-    V8ScriptValue other;
-    if (_other.isString()) {
-        other = QScriptEngine::newObject();
-        other.setProperty("message", _other.toString());
-    } else if (unwrapped) {
-        other = unwrapped->toV8Value();
-    } else {
-        other = QScriptEngine::newVariant(_other.toVariant());
-    }
-    V8ScriptValue result = makeError(other, type);
-    return ScriptValue(new ScriptValueV8Wrapper(this, std::move(result)));*/
-}
 // check syntax and when there are issues returns an actual "SyntaxError" with the details
 ScriptValue ScriptEngineV8::checkScriptSyntax(ScriptProgramPointer program) {
     return undefinedValue();
 }*/
-// this pulls from the best available information to create a detailed snapshot of the current exception
-ScriptValue ScriptEngineV8::cloneUncaughtException(const QString& extraDetail) {
-    if (!IS_THREADSAFE_INVOCATION(thread(), __FUNCTION__)) {
-        return nullValue();
-    }
-    if (!hasUncaughtException()) {
-        return nullValue();
-    }
-    v8::Locker locker(_v8Isolate);
-    v8::Isolate::Scope isolateScope(_v8Isolate);
-    v8::HandleScope handleScope(_v8Isolate);
-    v8::Context::Scope contextScope(getContext());
-    return nullValue();
-    //V8TODO
-    /*
-    auto exception = uncaughtException();
-    // ensure the error object is engine-local
-    auto err = makeError(exception);
-    // not sure why Qt does't offer uncaughtExceptionFileName -- but the line number
-    // on its own is often useless/wrong if arbitrarily married to a filename.
-    // when the error object already has this info, it seems to be the most reliable
-    auto fileName = exception.property("fileName").toString();
-    auto lineNumber = exception.property("lineNumber").toInt32();
-    // the backtrace, on the other hand, seems most reliable taken from uncaughtExceptionBacktrace
-    auto backtrace = uncaughtExceptionBacktrace();
-    if (backtrace.isEmpty()) {
-        // fallback to the error object
-        backtrace = exception.property("stack").toString().split(ScriptManager::SCRIPT_BACKTRACE_SEP);
-    }
-    // the ad hoc "detail" property can be used now to embed additional clues
-    auto detail = exception.property("detail").toString();
-    if (detail.isEmpty()) {
-        detail = extraDetail;
-    } else if (!extraDetail.isEmpty()) {
-        detail += "(" + extraDetail + ")";
-    }
-    if (lineNumber <= 0) {
-        lineNumber = uncaughtExceptionLineNumber();
-    }
-    if (fileName.isEmpty()) {
-        // climb the stack frames looking for something useful to display
-        for (auto c = QScriptEngine::currentContext(); c && fileName.isEmpty(); c = c->parentContext()) {
-            V8ScriptContextInfo info{ c };
-            if (!info.fileName().isEmpty()) {
-                // take fileName:lineNumber as a pair
-                fileName = info.fileName();
-                lineNumber = info.lineNumber();
-                if (backtrace.isEmpty()) {
-                    backtrace = c->backtrace();
-                }
-                break;
-            }
-        }
-    }
-    err.setProperty("fileName", fileNlintame);
-    err.setProperty("lineNumber", lineNumber);
-    err.setProperty("detail", detail);
-    err.setProperty("stack", backtrace.join(ScriptManager::SCRIPT_BACKTRACE_SEP));
-#ifdef DEBUG_JS_EXCEPTIONS
-    err.setProperty("_fileName", exception.property("fileName").toString());
-    err.setProperty("_stack", uncaughtExceptionBacktrace().join(SCRIPT_BACKTRACE_SEP));
-    err.setProperty("_lineNumber", uncaughtExceptionLineNumber());
-#endif
-    return err;
-    */
-}
 bool ScriptEngineV8::raiseException(const V8ScriptValue& exception) {
     if (!IS_THREADSAFE_INVOCATION(thread(), __FUNCTION__)) {
         return false;
     }
     //V8TODO
-    _v8Isolate->ThrowException(makeError(exception).get());
+    // _v8Isolate->ThrowException(makeError(exception).get());
     /*if (QScriptEngine::currentContext()) {
         // we have an active context / JS stack frame so throw the exception per usual
         QScriptEngine::currentContext()->throwValue(makeError(exception));
     return false;
 }
-bool ScriptEngineV8::maybeEmitUncaughtException(const QString& debugHint) {
-    /*
-    if (!IS_THREADSAFE_INVOCATION(thread(), __FUNCTION__)) {
-        return false;
-    }
-    if (!isEvaluating() && hasUncaughtException()) {
-        emit exception(cloneUncaughtException(debugHint));
-        clearExceptions();
-        return true;
-    }
-    */
-    return false;
-}
 // Lambda
 /*ScriptValue ScriptEngineV8::newLambdaFunction(std::function<V8ScriptValue(V8ScriptContext*, ScriptEngineV8*)> operation,
                                                  const V8ScriptValue& data,
             }
             if (hasUncaughtException()) {
-                auto err = cloneUncaughtException(__FUNCTION__);
 #ifdef DEBUG_JS_EXCEPTIONS
                 qCWarning(shared) << __FUNCTION__ << "---------- hasCaught:" << err.toString() << result.toString();
                 err.setProperty("_result", result);
 #endif
-                result = err;
+                result = nullValue();
             } else {
                 result = ScriptValue(new ScriptValueV8Wrapper(this, V8ScriptValue(this, v8Result)));
             }
     v8::ScriptOrigin scriptOrigin(getIsolate(), v8::String::NewFromUtf8(getIsolate(), fileName.toStdString().c_str()).ToLocalChecked());
     v8::Local<v8::Script> script;
     if (!v8::Script::Compile(getContext(), v8::String::NewFromUtf8(getIsolate(), sourceCode.toStdString().c_str()).ToLocalChecked(), &scriptOrigin).ToLocal(&script)) {
-        //V8TODO replace this with external function
+        setUncaughtException(tryCatch, "Error while compiling script");
-        int errorColumnNumber = 0;
-        int errorLineNumber = 0;
-        QString errorMessage = "";
-        QString errorBacktrace = "";
-        //v8::String::Utf8Value utf8Value(getIsolate(), tryCatch.Exception());
-        v8::String::Utf8Value utf8Value(getIsolate(), tryCatch.Message()->Get());
-        errorMessage = QString(*utf8Value);
-        v8::Local<v8::Message> exceptionMessage = tryCatch.Message();
-        if (!exceptionMessage.IsEmpty()) {
-            errorLineNumber = exceptionMessage->GetLineNumber(getContext()).FromJust();
-            errorColumnNumber = exceptionMessage->GetStartColumn(getContext()).FromJust();
-            v8::Local<v8::Value> backtraceV8String;
-            if (tryCatch.StackTrace(getContext()).ToLocal(&backtraceV8String)) {
-                if (backtraceV8String->IsString()) {
-                    if (v8::Local<v8::String>::Cast(backtraceV8String)->Length() > 0) {
-                        v8::String::Utf8Value backtraceUtf8Value(getIsolate(), backtraceV8String);
-                        errorBacktrace = *backtraceUtf8Value;
-                    }
-                }
-            }
-            qCDebug(scriptengine) << "Compiling script \"" << fileName << "\" failed on line " << errorLineNumber << " column " << errorColumnNumber << " with message: \"" << errorMessage <<"\" backtrace: " << errorBacktrace;
-        }
-        auto err = makeError(newValue(errorMessage));
-        raiseException(err);
-        maybeEmitUncaughtException("compile");
         _evaluatingCounter--;
-        return err;
+        return nullValue();
     }
     //qCDebug(scriptengine) << "Script compilation succesful: " << fileName;
     return ScriptValue(new ScriptValueV8Wrapper(this, std::move(resultValue)));
 }
+void ScriptEngineV8::setUncaughtEngineException(const QString &reason, const QString& info) {
+    auto ex = std::make_shared<ScriptEngineException>(reason, info);
+    setUncaughtException(ex);
+}
 void ScriptEngineV8::setUncaughtException(const v8::TryCatch &tryCatch, const QString& info) {
     if (!tryCatch.HasCaught()) {
         qCWarning(scriptengine) << "setUncaughtException called without exception";
         return;
     }
-    ScriptException ex;
+    auto ex = std::make_shared<ScriptException>();
-    ex.additionalInfo = info;
+    ex->additionalInfo = info;
     v8::Locker locker(_v8Isolate);
     v8::Isolate::Scope isolateScope(_v8Isolate);
     //v8::String::Utf8Value utf8Value(getIsolate(), tryCatch.Exception());
     v8::String::Utf8Value utf8Value(getIsolate(), tryCatch.Message()->Get());
-    ex.errorMessage = QString(*utf8Value);
+    ex->errorMessage = QString(*utf8Value);
     v8::Local<v8::Message> exceptionMessage = tryCatch.Message();
     if (!exceptionMessage.IsEmpty()) {
-        ex.errorLine = exceptionMessage->GetLineNumber(getContext()).FromJust();
+        ex->errorLine = exceptionMessage->GetLineNumber(getContext()).FromJust();
-        ex.errorColumn = exceptionMessage->GetStartColumn(getContext()).FromJust();
+        ex->errorColumn = exceptionMessage->GetStartColumn(getContext()).FromJust();
         v8::Local<v8::Value> backtraceV8String;
         if (tryCatch.StackTrace(getContext()).ToLocal(&backtraceV8String)) {
             if (backtraceV8String->IsString()) {
                 if (v8::Local<v8::String>::Cast(backtraceV8String)->Length() > 0) {
                     v8::String::Utf8Value backtraceUtf8Value(getIsolate(), backtraceV8String);
                     QString errorBacktrace = *backtraceUtf8Value;
-                    ex.backtrace = errorBacktrace.split("\n");
+                    ex->backtrace = errorBacktrace.split("\n");
                 }
             }
         }
     }
-    qCDebug(scriptengine) << "Emitting exception:" << ex;
+    setUncaughtException(ex);
-    _uncaughtException = ex;
-    emit exception(ex);
 }
+void ScriptEngineV8::setUncaughtException(std::shared_ptr<ScriptException> uncaughtException) {
+    qCDebug(scriptengine) << "Emitting exception:" << uncaughtException;
+    _uncaughtException = uncaughtException;
+    auto copy = uncaughtException->clone();
+    emit exception(copy);
+}
 QString ScriptEngineV8::formatErrorMessageFromTryCatch(v8::TryCatch &tryCatch) {
         v8::Context::Scope contextScope(getContext());
         ScriptProgramV8Wrapper* unwrapped = ScriptProgramV8Wrapper::unwrap(program);
         if (!unwrapped) {
-            errorValue = makeError(newValue("could not unwrap program"));
+            setUncaughtEngineException("Could not unwrap program", "Compile error");
-            raiseException(errorValue);
-            maybeEmitUncaughtException("compile");
             hasFailed = true;
         }
         if(!hasFailed) {
             ScriptSyntaxCheckResultPointer syntaxCheck = unwrapped->checkSyntax();
             if (syntaxCheck->state() == ScriptSyntaxCheckResult::Error) {
-                errorValue = makeError(newValue(syntaxCheck->errorMessage()));
+                setUncaughtEngineException(syntaxCheck->errorMessage(), "Compile error");
-                raiseException(errorValue);
-                maybeEmitUncaughtException("compile");
                 hasFailed = true;
             }
         }
                 Q_ASSERT(tryCatchRun.HasCaught());
                 auto runError = tryCatchRun.Message();
                 errorValue = ScriptValue(new ScriptValueV8Wrapper(this, V8ScriptValue(this, runError->Get())));
-                raiseException(errorValue);
+                raiseException(errorValue, "evaluation error");
-                maybeEmitUncaughtException("evaluate");
                 hasFailed = true;
             } else {
                 // V8TODO this is just to check if run will always return false for uncaught exception
 }
 void ScriptEngineV8::clearExceptions() {
-    _uncaughtException = ScriptException();
+    _uncaughtException.reset();
 }
 ScriptContext* ScriptEngineV8::currentContext() const {
 }
 bool ScriptEngineV8::hasUncaughtException() const {
-    return !_uncaughtException.isEmpty();
+    return _uncaughtException != nullptr;
 }
 bool ScriptEngineV8::isEvaluating() const {
 }*/
-ScriptException ScriptEngineV8::uncaughtException() const {
+std::shared_ptr<ScriptException> ScriptEngineV8::uncaughtException() const {
-    return _uncaughtException;
+    return _uncaughtException->clone();
+}
+bool ScriptEngineV8::raiseException(const QString& error, const QString &reason) {
+    return raiseException(ScriptValue(), reason);
 }
-bool ScriptEngineV8::raiseException(const ScriptValue& exception) {
+bool ScriptEngineV8::raiseException(const ScriptValue& exception, const QString &reason) {
     //V8TODO
     //Q_ASSERT(false);
 //    qCritical() << "Script exception occurred: " << exception.toString();
   //  emit
     //return raiseException(qException);
+    qCCritical(scriptengine) << "Raise exception for reason" << reason << "NOT IMPLEMENTED!";
     return false;
 }