Attempt at bandaid fixing concurrency issues II. Removed Script and C…

…ontinuation native objects

common/src/main/java/dev/latvian/mods/rhino/ArrowFunction.java

@@ -39,7 +39,7 @@ public ArrowFunction(Context cx, Scriptable scope, Callable targetFunction, Scri
 	@Override
 	public Object call(Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
 		Scriptable callThis = boundThis != null ? boundThis : cx.getTopCallOrThrow();
-		return targetFunction.call(cx, scope, callThis, args);
+		return cx.callSync(targetFunction, scope, callThis, args);
 	}
 
 	@Override

common/src/main/java/dev/latvian/mods/rhino/Context.java

@@ -21,10 +21,7 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
-import java.io.PrintWriter;
 import java.io.Reader;
-import java.io.StringWriter;
-import java.io.Writer;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -57,30 +54,10 @@
 
 @SuppressWarnings("ThrowableNotThrown")
 public class Context {
-	public static final String errorReporterProperty = "error reporter";
-
 	public static Context enter() {
 		return new Context();
 	}
 
-	/**
-	 * Call {@link
-	 * Callable#call(Context cx, Scriptable scope, Scriptable thisObj,
-	 * Object[] args)}
-	 * using the Context instance associated with the current thread.
-	 * If no Context is associated with the thread, then
-	 * {@link ContextFactory#makeContext()} will be called to construct
-	 * new Context instance. The instance will be temporary associated
-	 * with the thread during call to {@link ContextAction#run(Context)}.
-	 * <p>
-	 * It is allowed but not advisable to use null for <code>factory</code>
-	 * argument in which case the global static singleton ContextFactory
-	 * instance will be used to create new context instances.
-	 */
-	public static Object call(Context cx, final Callable callable, final Scriptable scope, final Scriptable thisObj, final Object[] args) {
-		return callable.call(cx, scope, thisObj, args);
-	}
-
 	/**
 	 * Report a warning using the error reporter for the current thread.
 	 *
@@ -108,17 +85,6 @@ public static void reportWarning(String message, Context cx) {
 		Context.reportWarning(cx, message, filename, linep[0], null, 0);
 	}
 
-	public static void reportWarning(Context cx, String message, Throwable t) {
-		int[] linep = {0};
-		String filename = getSourcePositionFromStack(cx, linep);
-		Writer sw = new StringWriter();
-		PrintWriter pw = new PrintWriter(sw);
-		pw.println(message);
-		t.printStackTrace(pw);
-		pw.flush();
-		Context.reportWarning(cx, sw.toString(), filename, linep[0], null, 0);
-	}
-
 	/**
 	 * Report an error using the error reporter for the current thread.
 	 *
@@ -336,6 +302,8 @@ public static String getSourcePositionFromStack(Context cx, int[] linep) {
 		return null;
 	}
 
+	public final Object lock = new Object();
+
 	// Generate an observer count on compiled code
 	public boolean generateObserverCount = false;
 	private Scriptable topCallScope;
@@ -631,95 +599,6 @@ public final Object evaluateReader(Scriptable scope, Reader in, String sourceNam
 		return null;
 	}
 
-	/**
-	 * Execute script that may pause execution by capturing a continuation.
-	 * Caller must be prepared to catch a ContinuationPending exception
-	 * and resume execution by calling
-	 * {@link #resumeContinuation(Object, Scriptable, Object)}.
-	 *
-	 * @param script The script to execute. Script must have been compiled
-	 *               with interpreted mode (optimization level -1)
-	 * @param scope  The scope to execute the script against
-	 * @throws ContinuationPending if the script calls a function that results
-	 *                             in a call to {@link #captureContinuation()}
-	 * @since 1.7 Release 2
-	 */
-	public Object executeScriptWithContinuations(Script script, Scriptable scope) throws ContinuationPending {
-		if (!(script instanceof InterpretedFunction) || !((InterpretedFunction) script).isScript()) {
-			// Can only be applied to scripts
-			throw new IllegalArgumentException("Script argument was not" + " a script or was not created by interpreted mode ");
-		}
-		return callFunctionWithContinuations((InterpretedFunction) script, scope, ScriptRuntime.EMPTY_OBJECTS);
-	}
-
-	/**
-	 * Call function that may pause execution by capturing a continuation.
-	 * Caller must be prepared to catch a ContinuationPending exception
-	 * and resume execution by calling
-	 * {@link #resumeContinuation(Object, Scriptable, Object)}.
-	 *
-	 * @param function The function to call. The function must have been
-	 *                 compiled with interpreted mode (optimization level -1)
-	 * @param scope    The scope to execute the script against
-	 * @param args     The arguments for the function
-	 * @throws ContinuationPending if the script calls a function that results
-	 *                             in a call to {@link #captureContinuation()}
-	 * @since 1.7 Release 2
-	 */
-	public Object callFunctionWithContinuations(Callable function, Scriptable scope, Object[] args) throws ContinuationPending {
-		if (!(function instanceof InterpretedFunction)) {
-			// Can only be applied to scripts
-			throw new IllegalArgumentException("Function argument was not" + " created by interpreted mode ");
-		}
-		if (hasTopCallScope()) {
-			throw new IllegalStateException("Cannot have any pending top " + "calls when executing a script with continuations");
-		}
-		// Annotate so we can check later to ensure no java code in
-		// intervening frames
-		isContinuationsTopCall = true;
-		return ScriptRuntime.doTopCall(this, scope, function, scope, args, isTopLevelStrict);
-	}
-
-	/**
-	 * Capture a continuation from the current execution. The execution must
-	 * have been started via a call to
-	 * {@link #executeScriptWithContinuations(Script, Scriptable)} or
-	 * {@link #callFunctionWithContinuations(Callable, Scriptable, Object[])}.
-	 * This implies that the code calling
-	 * this method must have been called as a function from the
-	 * JavaScript script. Also, there cannot be any non-JavaScript code
-	 * between the JavaScript frames (e.g., a call to eval()). The
-	 * ContinuationPending exception returned must be thrown.
-	 *
-	 * @return A ContinuationPending exception that must be thrown
-	 * @since 1.7 Release 2
-	 */
-	public ContinuationPending captureContinuation() {
-		return new ContinuationPending(Interpreter.captureContinuation(this));
-	}
-
-	/**
-	 * Restarts execution of the JavaScript suspended at the call
-	 * to {@link #captureContinuation()}. Execution of the code will resume
-	 * with the functionResult as the result of the call that captured the
-	 * continuation.
-	 * Execution of the script will either conclude normally and the
-	 * result returned, another continuation will be captured and
-	 * thrown, or the script will terminate abnormally and throw an exception.
-	 *
-	 * @param continuation   The value returned by
-	 *                       {@link ContinuationPending#getContinuation()}
-	 * @param functionResult This value will appear to the code being resumed
-	 *                       as the result of the function that captured the continuation
-	 * @throws ContinuationPending if another continuation is captured before
-	 *                             the code terminates
-	 * @since 1.7 Release 2
-	 */
-	public Object resumeContinuation(Object continuation, Scriptable scope, Object functionResult) throws ContinuationPending {
-		Object[] args = {functionResult};
-		return Interpreter.restartContinuation((NativeContinuation) continuation, this, scope, args);
-	}
-
 	/**
 	 * Compiles the source in the given reader.
 	 * <p>
@@ -1176,18 +1055,6 @@ public void addToScope(Scriptable scope, String name, Object value) {
 		}
 	}
 
-	/**
-	 * Execute top call to script or function.
-	 * When the runtime is about to execute a script or function that will
-	 * create the first stack frame with scriptable code, it calls this method
-	 * to perform the real call. In this way execution of any script
-	 * happens inside this function.
-	 */
-	protected Object doTopCall(Callable callable, Scriptable scope, Scriptable thisObj, Object[] args) {
-		Object result = callable.call(this, scope, thisObj, args);
-		return result instanceof ConsString ? result.toString() : result;
-	}
-
 	// custom data
 
 	/**
@@ -1359,37 +1226,100 @@ public final void setWrapFactory(WrapFactory wrapFactory) {
 		this.wrapFactory = wrapFactory;
 	}
 
-	public synchronized boolean hasTopCallScope() {
-		return topCallScope != null;
+	public boolean hasTopCallScope() {
+		synchronized (lock) {
+			return topCallScope != null;
+		}
 	}
 
-	public synchronized Scriptable getTopCallScope() {
-		return topCallScope;
+	public Scriptable getTopCallScope() {
+		synchronized (lock) {
+			return topCallScope;
+		}
 	}
 
-	public synchronized Scriptable getTopCallOrThrow() {
-		if (topCallScope == null) {
-			throw new IllegalStateException();
+	public Scriptable getTopCallOrThrow() {
+		synchronized (lock) {
+			if (topCallScope == null) {
+				throw new IllegalStateException();
+			}
+
+			return topCallScope;
 		}
+	}
 
-		return topCallScope;
+	public void setTopCall(Scriptable scope) {
+		synchronized (lock) {
+			topCallScope = scope;
+		}
 	}
 
-	public synchronized void setTopCall(Scriptable scope) {
-		topCallScope = scope;
+	public void storeScriptable(Scriptable value) {
+		synchronized (lock) {
+			// The previously stored scratchScriptable should be consumed
+			if (scratchScriptable != null) {
+				throw new IllegalStateException();
+			}
+			scratchScriptable = value;
+		}
 	}
 
-	public synchronized void storeScriptable(Scriptable value) {
-		// The previously stored scratchScriptable should be consumed
-		if (scratchScriptable != null) {
-			throw new IllegalStateException();
+	public Scriptable lastStoredScriptable() {
+		synchronized (lock) {
+			Scriptable result = scratchScriptable;
+			scratchScriptable = null;
+			return result;
+		}
+	}
+
+	/**
+	 * Call {@link
+	 * Callable#call(Context cx, Scriptable scope, Scriptable thisObj,
+	 * Object[] args)}
+	 * using the Context instance associated with the current thread.
+	 * If no Context is associated with the thread, then makeContext() will be called to construct
+	 * new Context instance. The instance will be temporary associated
+	 * with the thread during call to {@link ContextAction#run(Context)}.
+	 * <p>
+	 * It is allowed but not advisable to use null for <code>factory</code>
+	 * argument in which case the global static singleton ContextFactory
+	 * instance will be used to create new context instances.
+	 */
+	public Object callSync(Callable callable, Scriptable scope, Scriptable thisObj, Object[] args) {
+		synchronized (lock) {
+			return callable.call(this, scope, thisObj, args);
 		}
-		scratchScriptable = value;
 	}
 
-	public synchronized Scriptable lastStoredScriptable() {
-		Scriptable result = scratchScriptable;
-		scratchScriptable = null;
+	public Object doTopCall(Scriptable scope, Callable callable, Scriptable thisObj, Object[] args, boolean isTopLevelStrict) {
+		if (scope == null) {
+			throw new IllegalArgumentException();
+		}
+		if (hasTopCallScope()) {
+			throw new IllegalStateException();
+		}
+
+		Object result;
+		setTopCall(ScriptableObject.getTopLevelScope(scope));
+		boolean previousTopLevelStrict = this.isTopLevelStrict;
+		this.isTopLevelStrict = isTopLevelStrict;
+		try {
+			result = callSync(callable, scope, thisObj, args);
+
+			if (result instanceof ConsString) {
+				result = result.toString();
+			}
+		} finally {
+			setTopCall(null);
+			// Cleanup cached references
+			this.isTopLevelStrict = previousTopLevelStrict;
+
+			if (currentActivationCall != null) {
+				// Function should always call exitActivationFunction
+				// if it creates activation record
+				throw new IllegalStateException();
+			}
+		}
 		return result;
 	}
 }