diff --git a/benchmarks/src/jmh/java/org/mozilla/javascript/benchmarks/BuiltinBenchmark.java b/benchmarks/src/jmh/java/org/mozilla/javascript/benchmarks/BuiltinBenchmark.java index 27478b3352e..7a664df5df9 100644 --- a/benchmarks/src/jmh/java/org/mozilla/javascript/benchmarks/BuiltinBenchmark.java +++ b/benchmarks/src/jmh/java/org/mozilla/javascript/benchmarks/BuiltinBenchmark.java @@ -334,12 +334,11 @@ public Object dumbLambdaClassMethods(DumbLambdaState state) { private static class DumbLambdaClass extends ScriptableObject { - private static Object noop(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object noop(Context cx, VarScope scope, Object thisObj, Object[] args) { return Undefined.instance; } - private static Object setValue( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object setValue(Context cx, VarScope scope, Object thisObj, Object[] args) { if (args.length < 1) { throw ScriptRuntime.throwError(cx, scope, "Not enough args"); } @@ -349,8 +348,7 @@ private static Object setValue( return Undefined.instance; } - private static Object getValue( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object getValue(Context cx, VarScope scope, Object thisObj, Object[] args) { DumbLambdaClass self = LambdaConstructor.convertThisObject(thisObj, DumbLambdaClass.class); return self.value; diff --git a/rhino-engine/src/main/java/org/mozilla/javascript/engine/Builtins.java b/rhino-engine/src/main/java/org/mozilla/javascript/engine/Builtins.java index 6d779758c47..cf1b6994d27 100644 --- a/rhino-engine/src/main/java/org/mozilla/javascript/engine/Builtins.java +++ b/rhino-engine/src/main/java/org/mozilla/javascript/engine/Builtins.java @@ -11,7 +11,6 @@ import javax.script.ScriptContext; import org.mozilla.javascript.Context; import org.mozilla.javascript.ScriptRuntime; -import org.mozilla.javascript.Scriptable; import org.mozilla.javascript.ScriptableObject; import org.mozilla.javascript.TopLevel; import org.mozilla.javascript.Undefined; @@ -48,7 +47,7 @@ void register(Context cx, TopLevel scope, ScriptContext sc) { ScriptableObject.DONTENUM | ScriptableObject.READONLY); } - private static Object print(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object print(Context cx, VarScope scope, Object thisObj, Object[] args) { try { Builtins self = getSelf(scope); for (Object arg : args) { diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/debugger/Dim.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/debugger/Dim.java index 617b3049a67..9d42b0156e8 100644 --- a/rhino-tools/src/main/java/org/mozilla/javascript/tools/debugger/Dim.java +++ b/rhino-tools/src/main/java/org/mozilla/javascript/tools/debugger/Dim.java @@ -980,7 +980,7 @@ public static class StackFrame implements DebugFrame { private VarScope scope; /** The 'this' object. */ - private Scriptable thisObj; + private Object thisObj; /** Whether this frame represents a function (vs a top-level script). */ private boolean isFunction; @@ -1006,7 +1006,7 @@ private StackFrame(Context cx, Dim dim, FunctionSource fsource, boolean isFuncti /** Called when the stack frame is entered. */ @Override - public void onEnter(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public void onEnter(Context cx, VarScope scope, Object thisObj, Object[] args) { contextData.pushFrame(this); this.scope = scope; this.thisObj = thisObj; diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Global.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Global.java index 6e4ea8ba6d7..9827ae10047 100644 --- a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Global.java +++ b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Global.java @@ -155,6 +155,10 @@ public void init(Context cx) { history = (NativeArray) cx.newArray(this, 0); defineProperty("history", history, ScriptableObject.DONTENUM); + // Initialize Test262 support + Test262 proto262 = Test262.init(cx, this, Test262.RealmMode.STANDARD); + Test262.install(this, proto262, Test262.RealmMode.STANDARD); + initialized = true; } diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JavaPolicySecurity.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JavaPolicySecurity.java index 720563501bc..e536ff69784 100644 --- a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JavaPolicySecurity.java +++ b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JavaPolicySecurity.java @@ -23,7 +23,6 @@ import org.mozilla.javascript.Context; import org.mozilla.javascript.GeneratedClassLoader; import org.mozilla.javascript.Script; -import org.mozilla.javascript.Scriptable; import org.mozilla.javascript.VarScope; public class JavaPolicySecurity extends SecurityProxy { @@ -205,7 +204,7 @@ public Object callWithDomain( Context cx, Callable callable, VarScope scope, - Scriptable thisObj, + Object thisObj, Object[] args) { return doAction(securityDomain, () -> callable.call(cx, scope, thisObj, args)); } @@ -216,7 +215,7 @@ public Object callWithDomain( Context cx, Script script, VarScope scope, - Scriptable thisObj, + Object thisObj, Object[] args) { return doAction(securityDomain, () -> script.exec(cx, scope, thisObj)); } diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Test262.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Test262.java new file mode 100644 index 00000000000..76b4d8c5009 --- /dev/null +++ b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Test262.java @@ -0,0 +1,144 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +package org.mozilla.javascript.tools.shell; + +import org.mozilla.javascript.Context; +import org.mozilla.javascript.ScopeObject; +import org.mozilla.javascript.ScriptRuntime; +import org.mozilla.javascript.Scriptable; +import org.mozilla.javascript.ScriptableObject; +import org.mozilla.javascript.SymbolKey; +import org.mozilla.javascript.TopLevel; +import org.mozilla.javascript.Undefined; +import org.mozilla.javascript.VarScope; +import org.mozilla.javascript.typedarrays.NativeArrayBuffer; + +/** + * Implements the $262 object required by the Test262 ECMAScript conformance test suite. + * + *

This class provides the host-defined functions specified by Test262 for testing ECMAScript + * implementations. It supports creating new realms, evaluating scripts, and accessing global + * objects. + * + * @see + * Test262 Host-Defined Functions + */ +public class Test262 extends ScriptableObject { + + /** Enum to control how realms are initialized. */ + public enum RealmMode { + /** Uses initSafeStandardObjects - restricts Java access for sandboxing (used in tests) */ + SAFE, + /** Uses initStandardObjects - full access to Java integration (used in shell) */ + STANDARD + } + + private RealmMode realmMode; + + public Test262() { + super(); + } + + Test262(VarScope scope, Scriptable prototype, RealmMode mode) { + super(scope, prototype); + this.realmMode = mode; + } + + /** + * Initialize the $262 prototype object with all Test262 host-defined functions. + * + * @param cx the current Context + * @param scope the scope to install the prototype in + * @param mode the realm mode (SAFE for tests, STANDARD for shell) + * @return the initialized $262 prototype + */ + public static Test262 init(Context cx, VarScope scope, RealmMode mode) { + Test262 proto = new Test262(); + proto.realmMode = mode; + proto.setPrototype(getObjectPrototype(scope)); + proto.setParentScope(scope); + + proto.defineProperty(scope, "gc", 0, Test262::gc); + proto.defineProperty(scope, "createRealm", 0, Test262::createRealm); + proto.defineProperty(scope, "evalScript", 1, Test262::evalScript); + proto.defineProperty(scope, "detachArrayBuffer", 0, Test262::detachArrayBuffer); + + proto.defineProperty(cx, scope, "global", Test262::getGlobal, null, DONTENUM | READONLY); + proto.defineProperty(cx, scope, "agent", Test262::getAgent, null, DONTENUM | READONLY); + + proto.defineProperty(SymbolKey.TO_STRING_TAG, "__262__", DONTENUM | READONLY); + + ScriptableObject.defineProperty(scope, "__262__", proto, DONTENUM); + return proto; + } + + /** + * Install a $262 instance into a scope. + * + * @param scope the scope to install into + * @param parentScope the parent scope for the $262 instance + * @param mode the realm mode + * @return the installed $262 instance + */ + public static Test262 install(ScopeObject scope, Scriptable parentScope, RealmMode mode) { + Test262 instance = new Test262(scope, parentScope, mode); + + scope.put("$262", scope, instance); + scope.setAttributes("$262", ScriptableObject.DONTENUM); + + return instance; + } + + private static Object gc(Context cx, VarScope scope, Object thisObj, Object[] args) { + System.gc(); + return Undefined.instance; + } + + public static Object evalScript(Context cx, VarScope scope, Object thisObj, Object[] args) { + if (args.length == 0) { + throw ScriptRuntime.throwError(cx, scope, "not enough args"); + } + String source = Context.toString(args[0]); + return cx.evaluateString(scope, source, "", 1, null); + } + + public static Object getGlobal(Scriptable scriptable) { + return ((TopLevel) scriptable.getParentScope()).getGlobalThis(); + } + + public static Test262 createRealm(Context cx, VarScope scope, Object thisObj, Object[] args) { + // Get the realm mode from the parent $262 instance + Test262 parent = (Test262) ScriptRuntime.toObject(scope, thisObj); + RealmMode mode = parent.realmMode; + + // Create realm based on mode + TopLevel realm; + if (mode == RealmMode.SAFE) { + realm = cx.initSafeStandardObjects(new TopLevel()); + } else { + realm = cx.initStandardObjects(new TopLevel()); + } + + return install(realm, ScriptRuntime.toObject(realm, thisObj).getPrototype(), mode); + } + + public static Object detachArrayBuffer( + Context cx, VarScope scope, Object thisObj, Object[] args) { + Scriptable buf = ScriptRuntime.toObject(scope, args[0]); + if (buf instanceof NativeArrayBuffer) { + ((NativeArrayBuffer) buf).detach(); + } + return Undefined.instance; + } + + public static Object getAgent(Scriptable scriptable) { + throw new UnsupportedOperationException("$262.agent property not yet implemented"); + } + + @Override + public String getClassName() { + return "__262__"; + } +} diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Timers.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Timers.java index e91bb9f5864..7f7e477e765 100644 --- a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Timers.java +++ b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Timers.java @@ -6,7 +6,6 @@ import org.mozilla.javascript.Function; import org.mozilla.javascript.LambdaFunction; import org.mozilla.javascript.ScriptRuntime; -import org.mozilla.javascript.Scriptable; import org.mozilla.javascript.ScriptableObject; import org.mozilla.javascript.Undefined; import org.mozilla.javascript.VarScope; @@ -29,19 +28,14 @@ public class Timers { public void install(VarScope scope) { LambdaFunction setTimeout = new LambdaFunction( - scope, - "setTimeout", - 1, - (Context lcx, VarScope lscope, Scriptable thisObj, Object[] args) -> - setTimeout(args)); + scope, "setTimeout", 1, (lcx, lscope, thisObj, args) -> setTimeout(args)); ScriptableObject.defineProperty(scope, "setTimeout", setTimeout, ScriptableObject.DONTENUM); LambdaFunction clearTimeout = new LambdaFunction( scope, "clearTimeout", 1, - (Context lcx, VarScope lscope, Scriptable thisObj, Object[] args) -> - clearTimeout(args)); + (lcx, lscope, thisObj, args) -> clearTimeout(args)); ScriptableObject.defineProperty( scope, "clearTimeout", clearTimeout, ScriptableObject.DONTENUM); } diff --git a/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLLibImpl.java b/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLLibImpl.java index ff0df5ef5c3..2332f213670 100644 --- a/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLLibImpl.java +++ b/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLLibImpl.java @@ -25,7 +25,7 @@ public final class XMLLibImpl extends XMLLib implements Serializable { // EXPERIMENTAL Java interface // - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -6301237868232033480L; /** This experimental interface is undocumented. */ public static org.w3c.dom.Node toDomNode(Object xmlObject) { diff --git a/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLList.java b/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLList.java index dd0e20f04a1..2acb4c3a099 100644 --- a/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLList.java +++ b/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XMLList.java @@ -765,7 +765,7 @@ private XMLList getPropertyList(XMLName name) { } private Object applyOrCall( - boolean isApply, Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + boolean isApply, Context cx, VarScope scope, Object thisObj, Object[] args) { String methodName = isApply ? "apply" : "call"; if (!(thisObj instanceof XMLList) || ((XMLList) thisObj).targetProperty == null) throw ScriptRuntime.typeErrorById("msg.isnt.function", methodName); @@ -797,7 +797,7 @@ public Scriptable getExtraMethodSource(Context cx) { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { // This XMLList is being called as a Function. // Let's find the real Function object. if (targetProperty == null) throw ScriptRuntime.notFunctionError(this); @@ -812,7 +812,7 @@ public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args throw ScriptRuntime.typeErrorById("msg.incompat.call", methodName); } Object func = null; - Scriptable sobj = thisObj; + Scriptable sobj = ScriptRuntime.toObject(getDeclarationScope(), thisObj); while (sobj instanceof XMLObject) { XMLObject xmlObject = (XMLObject) sobj; @@ -839,4 +839,9 @@ public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args public Scriptable construct(Context cx, VarScope scope, Object[] args) { throw ScriptRuntime.typeErrorById("msg.not.ctor", "XMLList"); } + + @Override + public Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { + throw ScriptRuntime.typeErrorById("msg.not.ctor", "XMLList"); + } } diff --git a/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XmlNode.java b/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XmlNode.java index f54eaf668ad..7c8a1681d3e 100644 --- a/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XmlNode.java +++ b/rhino-xml/src/main/java/org/mozilla/javascript/xmlimpl/XmlNode.java @@ -20,7 +20,7 @@ import org.w3c.dom.UserDataHandler; class XmlNode implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 7498300745525888082L; private static final String XML_NAMESPACES_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/"; diff --git a/rhino/src/main/java/org/mozilla/javascript/ArrayLikeAbstractOperations.java b/rhino/src/main/java/org/mozilla/javascript/ArrayLikeAbstractOperations.java index 304b2b81c24..045de788053 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ArrayLikeAbstractOperations.java +++ b/rhino/src/main/java/org/mozilla/javascript/ArrayLikeAbstractOperations.java @@ -31,59 +31,6 @@ public interface LengthAccessor { public long getLength(Context cx, Scriptable o); } - /** - * Implements the methods "every", "filter", "forEach", "map", and "some" without using an - * IdFunctionObject. - */ - public static Object iterativeMethod( - Context cx, - IterativeOperation operation, - VarScope scope, - Object thisObj, - Object[] args, - LengthAccessor lengthAccessor) { - return iterativeMethod(cx, null, operation, scope, thisObj, args, lengthAccessor, true); - } - - /** - * Implements the methods "every", "filter", "forEach", "map", and "some" using an - * IdFunctionObject. - */ - public static Object iterativeMethod( - Context cx, - IdFunctionObject fun, - IterativeOperation operation, - VarScope scope, - Object thisObj, - Object[] args, - LengthAccessor lengthAccessor) { - return iterativeMethod(cx, fun, operation, scope, thisObj, args, lengthAccessor, false); - } - - private static Object iterativeMethod( - Context cx, - IdFunctionObject fun, - IterativeOperation operation, - VarScope scope, - Object thisObj, - Object[] args, - LengthAccessor lengthAccessor, - boolean skipCoercibleCheck) { - Scriptable o = ScriptRuntime.toObject(cx, scope, thisObj); - - if (!skipCoercibleCheck) { - if (IterativeOperation.FIND == operation - || IterativeOperation.FIND_INDEX == operation - || IterativeOperation.FIND_LAST == operation - || IterativeOperation.FIND_LAST_INDEX == operation) { - requireObjectCoercible(cx, o, fun); - } - } - - long length = lengthAccessor.getLength(cx, o); - return coercibleIterativeMethod(cx, operation, scope, o, args, length); - } - public static Object iterativeMethod( Context cx, Object tag, diff --git a/rhino/src/main/java/org/mozilla/javascript/BaseFunction.java b/rhino/src/main/java/org/mozilla/javascript/BaseFunction.java index d5386cd7419..eec59e7957b 100644 --- a/rhino/src/main/java/org/mozilla/javascript/BaseFunction.java +++ b/rhino/src/main/java/org/mozilla/javascript/BaseFunction.java @@ -6,6 +6,10 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; +import static org.mozilla.javascript.Symbol.Kind.REGULAR; + import java.util.EnumSet; import org.mozilla.javascript.xml.XMLObject; @@ -23,100 +27,108 @@ public class BaseFunction extends ScriptableObject implements Function { private static final Object FUNCTION_TAG = "Function"; private static final String FUNCTION_CLASS = "Function"; - static final String GENERATOR_FUNCTION_CLASS = "__GeneratorFunction"; + static final SymbolKey GENERATOR_FUNCTION_CLASS = + new SymbolKey("GeneratorFunctionPrototype", REGULAR); + static final SymbolKey ASYNC_FUNCTION_CLASS = new SymbolKey("AsyncFunctionPrototype", REGULAR); + static final SymbolKey ASYNC_GENERATOR_FUNCTION_CLASS = + new SymbolKey("AsyncGeneratorFunctionPrototype", REGULAR); private static final String APPLY_TAG = "APPLY_TAG"; private static final String CALL_TAG = "CALL_TAG"; private static final String PROTOTYPE_PROPERTY_NAME = "prototype"; - static LambdaConstructor init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor ctor = - new LambdaConstructor( - scope, - FUNCTION_CLASS, - 1, - BaseFunction::js_constructorCall, - BaseFunction::js_constructor); - + private static final ClassDescriptor DESCRIPTOR; + private static final ClassDescriptor ES6_DESCRIPTOR; + private static final ClassDescriptor GENERATOR_DESCRIPTOR; + // private static final ClassDescriptor GENERATOR_DESCRIPTOR; + private static final ClassDescriptor ASYNC_DESCRIPTOR; + private static final ClassDescriptor ASYNC_GENERATOR_DESCRIPTOR; + private static final JSDescriptor APPLY_DESCRIPTOR; + private static final JSDescriptor CALL_DESCRIPTOR; + + static { + var builder = + new ClassDescriptor.Builder( + FUNCTION_CLASS, + 1, + BaseFunction::js_constructor, + BaseFunction::js_constructor) + .withMethod(PROTO, "call", 1, BaseFunction::js_call) + .withMethod(PROTO, "apply", 2, BaseFunction::js_apply) + .withMethod(PROTO, "bind", 1, BaseFunction::js_bind) + .withMethod(PROTO, "toSource", 1, BaseFunction::js_toSource) + .withMethod(PROTO, "toString", 0, BaseFunction::js_toString) + .withMethod( + PROTO, + SymbolKey.HAS_INSTANCE, + 1, + BaseFunction::js_hasInstance, + DONTENUM | READONLY | PERMANENT, + DONTENUM | READONLY); + + DESCRIPTOR = builder.build(); + ES6_DESCRIPTOR = + builder.withProp( + PROTO, + "arguments", + BaseFunction::js_protoArgumentsGetter, + BaseFunction::js_protoArgumentsSetter, + DONTENUM | READONLY) + .build(); + + APPLY_DESCRIPTOR = DESCRIPTOR.findProtoDesc("apply"); + CALL_DESCRIPTOR = DESCRIPTOR.findProtoDesc("call"); + + GENERATOR_DESCRIPTOR = + new ClassDescriptor.Builder( + GENERATOR_FUNCTION_CLASS, + "GeneratorFunction", + 1, + BaseFunction::js_gen_constructor, + BaseFunction::js_gen_constructor) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value("GeneratorFunction", READONLY | DONTENUM)) + .build(); + + ASYNC_DESCRIPTOR = + new ClassDescriptor.Builder( + ASYNC_FUNCTION_CLASS, + "AsyncFunction", + 1, + BaseFunction::js_async_constructor, + BaseFunction::js_async_constructor) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value("AsyncFunction", READONLY | DONTENUM)) + .build(); + + ASYNC_GENERATOR_DESCRIPTOR = + new ClassDescriptor.Builder( + ASYNC_GENERATOR_FUNCTION_CLASS, + "AsyncGeneratorFunction", + 1, + BaseFunction::js_async_gen_constructor, + BaseFunction::js_async_gen_constructor) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value("AsyncGeneratorFunction", READONLY | DONTENUM)) + .build(); + } + + static JSFunction init(Context cx, VarScope scope, boolean sealed) { var proto = new LambdaFunction( scope, "", 0, null, (lcx, lscope, lthisObj, largs) -> Undefined.instance); - proto.defineProperty("constructor", ctor, DONTENUM); - // Set the constructor correctly here. i.e. ctor.prototype.constructor == ctor - // Redo the stuff about setupDefaultPrototype. - - ctor.setPrototypeProperty(proto); - // Do this early, so that the functions on the prototype get - // the right prototype... - ScriptableObject.defineProperty(scope, FUNCTION_CLASS, ctor, DONTENUM); - ctor.setPrototype((Scriptable) ctor.getPrototypeProperty()); - - defKnownBuiltInOnProto(ctor, APPLY_TAG, scope, "apply", 2, BaseFunction::js_apply); - defOnProto(ctor, scope, "bind", 1, BaseFunction::js_bind); - defKnownBuiltInOnProto(ctor, CALL_TAG, scope, "call", 1, BaseFunction::js_call); - defOnProto(ctor, scope, "toSource", 1, BaseFunction::js_toSource); - defOnProto(ctor, scope, "toString", 0, BaseFunction::js_toString); - defOnProto( - ctor, - scope, - SymbolKey.HAS_INSTANCE, - 1, - BaseFunction::js_hasInstance, - DONTENUM | READONLY | PERMANENT); - - // Function.prototype attributes: see ECMA 15.3.3.1 - ctor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - if (cx.getLanguageVersion() >= Context.VERSION_ES6) { - ctor.setStandardPropertyAttributes(READONLY | DONTENUM); - } - - if (!cx.isStrictMode() && cx.getLanguageVersion() >= Context.VERSION_ES6) { - ctor.definePrototypeProperty( - cx, - "arguments", - BaseFunction::js_protoArgumentsGetter, - BaseFunction::js_protoArgumentsSetter, - DONTENUM | READONLY); - } - - ScriptableObject.defineProperty(scope, FUNCTION_CLASS, ctor, DONTENUM); - if (sealed) { - ctor.sealObject(); - ((ScriptableObject) ctor.getPrototypeProperty()).sealObject(); + if (cx.getLanguageVersion() < Context.VERSION_ES6) { + return DESCRIPTOR.buildConstructor(cx, scope, proto, sealed); + } else { + return ES6_DESCRIPTOR.buildConstructor(cx, scope, proto, sealed); } - return ctor; - } - - private static void defOnProto( - LambdaConstructor constructor, - VarScope scope, - String name, - int length, - SerializableCallable target) { - constructor.definePrototypeMethod(scope, name, length, target); - } - - private static void defKnownBuiltInOnProto( - LambdaConstructor constructor, - Object tag, - VarScope scope, - String name, - int length, - SerializableCallable target) { - constructor.defineKnownBuiltInPrototypeMethod( - tag, scope, name, length, null, target, DONTENUM, DONTENUM | READONLY); - } - - private static void defOnProto( - LambdaConstructor constructor, - VarScope scope, - SymbolKey name, - int length, - SerializableCallable target, - int attributes) { - constructor.definePrototypeMethod( - scope, name, length, null, target, attributes, DONTENUM | READONLY); } /** @@ -127,54 +139,75 @@ static void init(VarScope scope, boolean sealed) { init(Context.getContext(), scope, sealed); } - static Object initAsGeneratorFunction(VarScope scope, boolean sealed) { + static Object initAsGeneratorFunction(Context cx, VarScope scope, boolean sealed) { var proto = new NativeObject(); - VarScope top = ScriptableObject.getTopLevelScope(scope); - - var function = (Scriptable) ScriptableObject.getProperty(scope, FUNCTION_CLASS); - var functionProto = - (Scriptable) ScriptableObject.getProperty(function, PROTOTYPE_PROPERTY_NAME); - proto.setPrototype(functionProto); - var iterator = (Scriptable) ScriptableObject.getProperty(scope, "Iterator"); - ScriptableObject.putProperty( + return GENERATOR_DESCRIPTOR.buildConstructor( + cx, + scope, proto, - PROTOTYPE_PROPERTY_NAME, - ScriptableObject.getTopScopeValue(top, ES6Generator.GENERATOR_TAG)); + sealed, + (c, ctor) -> { + VarScope top = ScriptableObject.getTopLevelScope(scope); + + var function = (Scriptable) ScriptableObject.getProperty(scope, FUNCTION_CLASS); + var functionProto = + (Scriptable) + ScriptableObject.getProperty(function, PROTOTYPE_PROPERTY_NAME); + proto.setPrototype(functionProto); - LambdaConstructor ctor = - new LambdaConstructor( - scope, - GENERATOR_FUNCTION_CLASS, - 1, - proto, - BaseFunction::js_gen_constructorCall, - BaseFunction::js_gen_constructor); + var generatorProto = + ScriptableObject.getTopScopeValue(top, ES6Generator.GENERATOR_TAG); - proto.defineProperty("constructor", ctor, READONLY | DONTENUM); + proto.setAttributes("constructor", DONTENUM | READONLY); + proto.defineProperty("prototype", generatorProto, READONLY | DONTENUM); + }); + } - // Function.prototype attributes: see ECMA 15.3.3.1 - ctor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); + static Object initAsAsyncFunction(Context cx, VarScope scope, boolean sealed) { + var proto = new NativeObject(); - proto.defineProperty(SymbolKey.TO_STRING_TAG, "GeneratorFunction", READONLY | DONTENUM); - ScriptableObject.putProperty(scope, GENERATOR_FUNCTION_CLASS, ctor); - // Function.prototype attributes: see ECMA 15.3.3.1 - // The "GeneratorFunction" name actually never appears in the global scope. - // Return it here so it can be cached as a "builtin" - return ctor; + return ASYNC_DESCRIPTOR.buildConstructor( + cx, + scope, + proto, + sealed, + (c, ctor) -> { + var function = (Scriptable) ScriptableObject.getProperty(scope, FUNCTION_CLASS); + var functionProto = + (Scriptable) + ScriptableObject.getProperty(function, PROTOTYPE_PROPERTY_NAME); + proto.setPrototype(functionProto); + proto.setAttributes("constructor", DONTENUM | READONLY); + }); } - public BaseFunction() { - createProperties(); + static Object initAsAsyncGeneratorFunction(Context cx, VarScope scope, boolean sealed) { + var proto = new NativeObject(); + + return ASYNC_GENERATOR_DESCRIPTOR.buildConstructor( + cx, + scope, + proto, + sealed, + (c, ctor) -> { + var function = (Scriptable) ScriptableObject.getProperty(scope, FUNCTION_CLASS); + var functionProto = + (Scriptable) + ScriptableObject.getProperty(function, PROTOTYPE_PROPERTY_NAME); + proto.setPrototype(functionProto); + proto.setAttributes("constructor", DONTENUM | READONLY); + }); } - public BaseFunction(boolean isGenerator) { + public BaseFunction(VarScope scope) { + declarationScope = scope; createProperties(); - this.isGeneratorFunction = isGenerator; } public BaseFunction(VarScope scope, Scriptable prototype) { super(scope, prototype); + declarationScope = scope; createProperties(); ScriptRuntime.setBuiltinProtoAndParent(this, scope, TopLevel.Builtins.Function); } @@ -319,6 +352,11 @@ protected static boolean prototypeDescSetter( } } + static DescriptorInfo createThrowingProp(Context cx, VarScope scope, ScriptableObject obj) { + var thrower = ScriptRuntime.typeErrorThrower(scope); + return new DescriptorInfo(false, NOT_FOUND, true, thrower, thrower, null); + } + protected final boolean defaultHas(String name) { return super.has(name, this); } @@ -333,7 +371,10 @@ protected final void defaultPut(String name, Object value) { @Override public String getClassName() { - return isGeneratorFunction() ? GENERATOR_FUNCTION_CLASS : FUNCTION_CLASS; + if (isGeneratorFunction()) { + return isAsync() ? "AsyncGeneratorFunction" : "GeneratorFunction"; + } + return isAsync() ? "AsyncFunction" : FUNCTION_CLASS; } // Generated code will override this @@ -395,18 +436,34 @@ public boolean hasInstance(Scriptable instance) { Id_arguments = 5, MAX_INSTANCE_ID = 5; - static boolean isApply(KnownBuiltInFunction f) { - return f.getTag() == APPLY_TAG; + static boolean isApply(Callable f) { + if (f instanceof KnownBuiltInFunction) { + var kf = (KnownBuiltInFunction) f; + var tag = kf.getTag(); + return tag == APPLY_TAG; + } + if (f instanceof JSFunction) { + return ((JSFunction) f).getDescriptor() == APPLY_DESCRIPTOR; + } + return false; } - static boolean isApplyOrCall(KnownBuiltInFunction f) { - var tag = f.getTag(); - return tag == APPLY_TAG || tag == CALL_TAG; + static boolean isApplyOrCall(Callable f) { + if (f instanceof KnownBuiltInFunction) { + var kf = (KnownBuiltInFunction) f; + var tag = kf.getTag(); + return tag == APPLY_TAG || tag == CALL_TAG; + } + if (f instanceof JSFunction) { + var desc = ((JSFunction) f).getDescriptor(); + return desc == APPLY_DESCRIPTOR || desc == CALL_DESCRIPTOR; + } + return false; } private static Object js_hasInstance( - Context cx, VarScope scope, Object thisObj, Object[] args) { - if (!(thisObj instanceof Callable)) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + if (!(thisObj instanceof Callable && thisObj instanceof Scriptable)) { return false; } Object protoProp = null; @@ -434,7 +491,8 @@ private static Object js_hasInstance( : "unknown"); } - private static Object js_bind(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_bind( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (!(thisObj instanceof Callable)) { throw ScriptRuntime.notFunctionError(thisObj); } @@ -443,25 +501,29 @@ private static Object js_bind(Context cx, VarScope scope, Object thisObj, Object final Scriptable boundThis; final Object[] boundArgs; if (argc > 0) { - boundThis = ScriptRuntime.toObjectOrNull(cx, args[0], scope); + boundThis = ScriptRuntime.toObjectOrNull(cx, args[0], s); boundArgs = new Object[argc - 1]; System.arraycopy(args, 1, boundArgs, 0, argc - 1); } else { boundThis = null; boundArgs = ScriptRuntime.emptyArgs; } - return new BoundFunction(cx, scope, targetFunction, boundThis, boundArgs); + return new BoundFunction(cx, s, targetFunction, boundThis, boundArgs); } - private static Object js_apply(Context cx, VarScope scope, Object thisObj, Object[] args) { - return ScriptRuntime.applyOrCall(true, cx, scope, (Scriptable) thisObj, args); + private static Object js_apply( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return ScriptRuntime.applyOrCall(true, cx, f.getDeclarationScope(), thisObj, args); } - private static Object js_call(Context cx, VarScope scope, Object thisObj, Object[] args) { - return ScriptRuntime.applyOrCall(false, cx, scope, (Scriptable) thisObj, args); + private static Object js_call( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var thisArg = ScriptRuntime.toObject(f.getDeclarationScope(), thisObj); + return ScriptRuntime.applyOrCall(false, cx, f.getDeclarationScope(), thisArg, args); } - private static Object js_toSource(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toSource( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { BaseFunction realf = realFunction(thisObj, "toSource"); int indent = 0; EnumSet flags = EnumSet.of(DecompilerFlag.TO_SOURCE); @@ -476,39 +538,45 @@ private static Object js_toSource(Context cx, VarScope scope, Object thisObj, Ob return realf.decompile(indent, flags); } - private static Object js_toString(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toString( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { BaseFunction realf = realFunction(thisObj, "toString"); int indent = ScriptRuntime.toInt32(args, 0); return realf.decompile(indent, EnumSet.noneOf(DecompilerFlag.class)); } - private static Scriptable js_gen_constructorCall( - Context cx, VarScope scope, Object thisObj, Object[] args) { - return js_gen_constructor(cx, scope, args); + private static Scriptable js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return jsConstructor(cx, f, nt, f.getDeclarationScope(), args, false); } - private static Scriptable js_constructor(Context cx, VarScope scope, Object[] args) { - return jsConstructor(cx, scope, args, false); + private static Scriptable js_gen_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return jsConstructor(cx, f, nt, f.getDeclarationScope(), args, true); } - private static Scriptable js_constructorCall( - Context cx, VarScope scope, Object thisObj, Object[] args) { - return js_constructor(cx, scope, args); + private static Scriptable js_async_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return jsConstructor(cx, f, nt, f.getDeclarationScope(), args, false, true); } - private static Scriptable js_gen_constructor(Context cx, VarScope scope, Object[] args) { - return jsConstructor(cx, scope, args, true); + private static Scriptable js_async_gen_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return jsConstructor(cx, f, nt, f.getDeclarationScope(), args, true, true); } private static BaseFunction realFunction(Object thisObj, String functionName) { if (thisObj == null) { throw ScriptRuntime.notFunctionError(null); } - Object x = ((Scriptable) thisObj).getDefaultValue(ScriptRuntime.FunctionClass); - if (x instanceof Delegator) { - x = ((Delegator) x).getDelegee(); + if (thisObj instanceof Scriptable) { + Object x = ((Scriptable) thisObj).getDefaultValue(ScriptRuntime.FunctionClass); + if (x instanceof Delegator) { + x = ((Delegator) x).getDelegee(); + } + return ensureType(x, BaseFunction.class, functionName); } - return ensureType(x, BaseFunction.class, functionName); + return ensureType(thisObj, BaseFunction.class, functionName); } /** Make value as DontEnum, DontDelete, ReadOnly prototype property of this Function object */ @@ -531,7 +599,7 @@ protected Scriptable getClassPrototype() { /** Should be overridden. */ @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { return Undefined.instance; } @@ -574,6 +642,11 @@ public Scriptable construct(Context cx, VarScope scope, Object[] args) { return result; } + @Override + public Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { + return construct(cx, s, args); + } + /** * Creates new script object. The default implementation of {@link #construct} uses this method * to to get the value for {@code thisObj} argument when invoking {@link #call}. The method is @@ -588,6 +661,25 @@ public Scriptable createObject(Context cx, VarScope scope) { return newInstance; } + public Scriptable createObject(Context cx, VarScope scope, Object nt) { + Scriptable newInstance = new NativeObject(); + Object proto; + if (nt instanceof JSFunction) { + proto = ((JSFunction) nt).getPrototypeProperty(); + } else { + proto = Undefined.instance; + } + + if (proto instanceof Scriptable) { + newInstance.setPrototype((Scriptable) proto); + } else { + newInstance.setPrototype(getClassPrototype()); + } + + newInstance.setParentScope(getParentScope()); + return newInstance; + } + /** * Decompile the source information associated with this js function/script back into a string. * @@ -724,14 +816,17 @@ Object getArguments() { return argumentsObj; } Context cx = Context.getContext(); + if (this instanceof JSFunction + && ((JSFunction) this).isStrict() + && cx.getLanguageVersion() >= Context.VERSION_ES6) { + ScriptRuntime.ThrowTypeError.throwNotAllowed(); + } + NativeCall activation = ScriptRuntime.findFunctionActivation(cx, this); // return (activation == null) ? null : activation.get("arguments", activation); if (activation == null) { return null; } - if (activation.function.isStrict() && cx.getLanguageVersion() >= Context.VERSION_ES6) { - ScriptRuntime.ThrowTypeError.throwNotAllowed(); - } Object arguments = activation.get("arguments", activation); if (arguments instanceof Arguments && cx.getLanguageVersion() >= Context.VERSION_ES6) { return new Arguments.ReadonlyArguments((Arguments) arguments, cx); @@ -742,10 +837,29 @@ Object getArguments() { void setArguments(Object caller) {} private static Scriptable jsConstructor( - Context cx, VarScope scope, Object[] args, boolean isGeneratorFunction) { + Context cx, + JSFunction f, + Object nt, + VarScope scope, + Object[] args, + boolean isGeneratorFunction) { + return jsConstructor(cx, f, nt, scope, args, isGeneratorFunction, false); + } + + private static Scriptable jsConstructor( + Context cx, + JSFunction f, + Object nt, + VarScope scope, + Object[] args, + boolean isGeneratorFunction, + boolean isAsync) { int arglen = args.length; StringBuilder sourceBuf = new StringBuilder(); + if (isAsync) { + sourceBuf.append("async "); + } sourceBuf.append("function "); if (isGeneratorFunction) { sourceBuf.append("* "); @@ -777,7 +891,7 @@ private static Scriptable jsConstructor( String sourceURI = ScriptRuntime.makeUrlForGeneratedScript(false, filename, linep[0]); - TopLevel global = ScriptableObject.getTopLevelScope(scope); + TopLevel global = ScriptableObject.getTopLevelScope(f.getDeclarationScope()); ErrorReporter reporter; reporter = DefaultErrorReporter.forEval(cx.getErrorReporter()); @@ -789,7 +903,26 @@ private static Scriptable jsConstructor( // Compile with explicit interpreter instance to force interpreter // mode. - return cx.compileFunction(global, source, evaluator, reporter, sourceURI, 1, null); + var res = + (JSFunction) + cx.compileFunction(global, source, evaluator, reporter, sourceURI, 1, null); + + boolean resIsGenerator = res.getDescriptor().isES6Generator(); + boolean resIsAsync = res.getDescriptor().isAsync(); + if (resIsGenerator && resIsAsync) { + ScriptRuntime.setBuiltinProtoAndParent( + (ScriptableObject) res, f, nt, scope, TopLevel.Builtins.AsyncGeneratorFunction); + } else if (resIsGenerator) { + ScriptRuntime.setBuiltinProtoAndParent( + (ScriptableObject) res, f, nt, scope, TopLevel.Builtins.GeneratorFunction); + } else if (resIsAsync) { + ScriptRuntime.setBuiltinProtoAndParent( + (ScriptableObject) res, f, nt, scope, TopLevel.Builtins.AsyncFunction); + } else { + ScriptRuntime.setBuiltinProtoAndParent( + (ScriptableObject) res, f, nt, scope, TopLevel.Builtins.Function); + } + return res; } public void setHomeObject(Scriptable homeObject) { @@ -806,15 +939,12 @@ public boolean isConstructor() { && this.getHomeObject() != null); } - private static final int Id_constructor = 1, - Id_toString = 2, - Id_toSource = 3, - Id_apply = 4, - Id_call = 5, - Id_bind = 6, - SymbolId_hasInstance = 7, - MAX_PROTOTYPE_ID = SymbolId_hasInstance; + @Override + public VarScope getDeclarationScope() { + return declarationScope; + } + private final VarScope declarationScope; private Object prototypeProperty; private Object argumentsObj = NOT_FOUND; private Object nameValue = null; diff --git a/rhino/src/main/java/org/mozilla/javascript/BoundFunction.java b/rhino/src/main/java/org/mozilla/javascript/BoundFunction.java index 554b8008b03..6092d0a2ad2 100644 --- a/rhino/src/main/java/org/mozilla/javascript/BoundFunction.java +++ b/rhino/src/main/java/org/mozilla/javascript/BoundFunction.java @@ -26,6 +26,7 @@ public BoundFunction( Callable targetFunction, Scriptable boundThis, Object[] boundArgs) { + super(scope); this.targetFunction = targetFunction; this.boundThis = boundThis; this.boundArgs = boundArgs; @@ -58,7 +59,7 @@ void setArguments(Object caller) { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] extraArgs) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] extraArgs) { return targetFunction.call(cx, scope, getCallThis(), concat(boundArgs, extraArgs)); } diff --git a/rhino/src/main/java/org/mozilla/javascript/Callable.java b/rhino/src/main/java/org/mozilla/javascript/Callable.java index 4fcca2b21be..bba87f56de0 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Callable.java +++ b/rhino/src/main/java/org/mozilla/javascript/Callable.java @@ -20,5 +20,5 @@ public interface Callable { * @param args the array of arguments * @return the result of the call */ - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args); + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args); } diff --git a/rhino/src/main/java/org/mozilla/javascript/CatchScope.java b/rhino/src/main/java/org/mozilla/javascript/CatchScope.java new file mode 100644 index 00000000000..8a264518658 --- /dev/null +++ b/rhino/src/main/java/org/mozilla/javascript/CatchScope.java @@ -0,0 +1,14 @@ +package org.mozilla.javascript; + +public class CatchScope extends DeclarationScope { + private static final long serialVersionUID = -7471457301304454454L; + + public CatchScope(VarScope parentScope) { + super(parentScope); + } + + @Override + public boolean isNestedScope() { + return true; + } +} diff --git a/rhino/src/main/java/org/mozilla/javascript/ClassDescriptor.java b/rhino/src/main/java/org/mozilla/javascript/ClassDescriptor.java index 7f8b9c687fc..d6d98d069ee 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ClassDescriptor.java +++ b/rhino/src/main/java/org/mozilla/javascript/ClassDescriptor.java @@ -211,7 +211,7 @@ public ScriptableObject populateGlobal( ScriptableObject.defineProperty( scope, ctorDesc.name.toString(), global, ctorDesc.attributes); for (var e : ctorDescs) { - var f = new JSFunction(scope, e.funcDesc, null, null); + var f = new JSFunction(scope, e.funcDesc, null, Undefined.instance, null); f.setStandardPropertyAttributes(e.stdAttrs); if (e.name instanceof String) { global.put((String) e.name, global, f); @@ -241,7 +241,7 @@ public JSFunction buildConstructor( ScriptableObject proto, boolean sealed, BiConsumer customStep) { - var ctor = new JSFunction(scope, ctorDesc.funcDesc, null, null); + var ctor = new JSFunction(scope, ctorDesc.funcDesc, null, Undefined.instance, null); if (proto != null) { ctor.setPrototypeProperty(proto); @@ -258,7 +258,7 @@ public JSFunction buildConstructor( } for (var e : ctorDescs) { - var f = new JSFunction(scope, e.funcDesc, null, null); + var f = new JSFunction(scope, e.funcDesc, null, Undefined.instance, null); f.setStandardPropertyAttributes(e.stdAttrs); if (e.name instanceof String) { ctor.put((String) e.name, ctor, f); @@ -280,7 +280,7 @@ public JSFunction buildConstructor( } proto.setAttributes("constructor", DONTENUM); for (var e : protoDescs) { - var f = new JSFunction(scope, e.funcDesc, null, null); + var f = new JSFunction(scope, e.funcDesc, null, Undefined.instance, null); f.setStandardPropertyAttributes(e.stdAttrs); if (e.name instanceof String) { proto.put((String) e.name, proto, f); @@ -782,7 +782,7 @@ public ClassDescriptor build() { private static class BuiltInJSCode extends JSCode implements Serializable { - private static final long serialVersionUID = 2691205302914111400L; + private static final long serialVersionUID = -346984669839537590L; private final JSCodeExec exec; private final JSCodeResume resume; diff --git a/rhino/src/main/java/org/mozilla/javascript/CodeGenUtils.java b/rhino/src/main/java/org/mozilla/javascript/CodeGenUtils.java index 412a64b272b..29419ed639d 100644 --- a/rhino/src/main/java/org/mozilla/javascript/CodeGenUtils.java +++ b/rhino/src/main/java/org/mozilla/javascript/CodeGenUtils.java @@ -26,17 +26,23 @@ public static void fillInForNestedFunction( || fnParent instanceof Block)) { builder.declaredAsFunctionExpression = true; boolean isArrow = fn.getFunctionType() == FunctionNode.ARROW_FUNCTION; + boolean isAsyncNonGenerator = fn.isAsync() && !fn.isES6Generator(); builder.hasLexicalThis = isArrow; - builder.hasPrototype = !isArrow; - if (!isArrow) { + builder.hasPrototype = !isArrow && !isAsyncNonGenerator; + if (!isArrow && !isAsyncNonGenerator) { builder.constructor = builder.code; } else { builder.constructor = new JSCode.NullBuilder(); } } else { builder.hasLexicalThis = false; - builder.hasPrototype = true; - builder.constructor = builder.code; + boolean isAsyncNonGenerator = fn.isAsync() && !fn.isES6Generator(); + builder.hasPrototype = !isAsyncNonGenerator; + if (!isAsyncNonGenerator) { + builder.constructor = builder.code; + } else { + builder.constructor = new JSCode.NullBuilder(); + } } fillInForFunction(builder, fn); @@ -55,6 +61,9 @@ private static void fillInForFunction(JSDescriptor.Builder builder, FunctionNode if (fn.isES6Generator()) { builder.isES6Generator = true; } + if (fn.isAsync()) { + builder.isAsync = true; + } if (fn.isShorthand()) { builder.isShorthand = true; } @@ -124,7 +133,8 @@ public static > void setConstructor( if (scriptOrFn instanceof FunctionNode) { FunctionNode f = (FunctionNode) scriptOrFn; boolean isArrow = f.getFunctionType() == FunctionNode.ARROW_FUNCTION; - if (isArrow || f.isMethodDefinition() || f.isGenerator()) { + boolean isAsyncNonGenerator = f.isAsync() && !f.isES6Generator(); + if (isArrow || f.isMethodDefinition() || f.isGenerator() || isAsyncNonGenerator) { builder.constructor = new JSCode.NullBuilder(); } else { builder.constructor = builder.code; diff --git a/rhino/src/main/java/org/mozilla/javascript/CodeGenerator.java b/rhino/src/main/java/org/mozilla/javascript/CodeGenerator.java index 0eb9c63b8c2..8b7123c7b27 100644 --- a/rhino/src/main/java/org/mozilla/javascript/CodeGenerator.java +++ b/rhino/src/main/java/org/mozilla/javascript/CodeGenerator.java @@ -283,7 +283,8 @@ private void visitStatement(Node node, int initialStackDepth) { // at script/function start. // In addition, function expressions can not be present here // at statement level, they must only be present as expressions. - if (fnType == FunctionNode.FUNCTION_EXPRESSION_STATEMENT) { + if (fnType == FunctionNode.FUNCTION_EXPRESSION_STATEMENT + || fnType == FunctionNode.FUNCTION_BLOCK_SCOPED) { addIndexOp(Icode_CLOSURE_STMT, fnIndex); } else { if (fnType != FunctionNode.FUNCTION_STATEMENT) { @@ -311,6 +312,7 @@ private void visitStatement(Node node, int initialStackDepth) { case Token.LABEL: case Token.LOOP: case Token.BLOCK: + case Token.SCOPE_BLOCK: case Token.EMPTY: case Token.WITH: updateLineNumber(node); @@ -328,8 +330,12 @@ private void visitStatement(Node node, int initialStackDepth) { stackChange(-1); break; - case Token.LEAVEWITH: - addToken(Token.LEAVEWITH); + case Token.ENTER_SCOPE: + visitEnterScope(node, child); + break; + + case Token.LEAVE_SCOPE: + addToken(Token.LEAVE_SCOPE); break; case Token.LOCAL_BLOCK: @@ -553,6 +559,25 @@ private void visitStatement(Node node, int initialStackDepth) { } } + private void visitEnterScope(Node node, Node child) { + addToken(Token.ENTER_SCOPE); + stackChange(1); + Object[] names = (Object[]) node.getProp(Node.OBJECT_IDS_PROP); + int i = 0; + while (child != null) { + addIcode(Icode_DUP); + stackChange(1); + visitExpression(child, 0); + addStringOp(Token.SETNAME, (String) names[i]); + addIcode(Icode_POP); + stackChange(-2); + child = child.getNext(); + i++; + } + addIcode(Icode_POP); + stackChange(-1); + } + private void visitExpression(Node node, int contextFlags) { int type = node.getType(); Node child = node.getFirstChild(); @@ -1052,6 +1077,7 @@ private void visitExpression(Node node, int contextFlags) { case Token.THIS: case Token.SUPER: case Token.THISFN: + case Token.NEW_TARGET: case Token.FALSE: case Token.TRUE: addToken(type); @@ -1156,16 +1182,19 @@ private void visitExpression(Node node, int contextFlags) { case Token.YIELD: case Token.YIELD_STAR: + case Token.AWAIT: if (child != null) { visitExpression(child, 0); } else { addIcode(Icode_UNDEF); stackChange(1); } - if (type == Token.YIELD) { - addToken(Token.YIELD); - } else { + if (type == Token.YIELD_STAR) { addIcode(Icode_YIELD_STAR); + } else { + // Token.YIELD and Token.AWAIT both use the same yield opcode; + // the async Promise runner drives the generator for await. + addToken(Token.YIELD); } addUint16(node.getLineno() & 0xFFFF); break; @@ -1178,7 +1207,17 @@ private void visitExpression(Node node, int contextFlags) { addToken(Token.ENTERWITH); stackChange(-1); visitExpression(with.getFirstChild(), 0); - addToken(Token.LEAVEWITH); + addToken(Token.LEAVE_SCOPE); + break; + } + + case Token.SCOPEEXPR: + { + Node enterScope = node.getFirstChild(); + Node expr = enterScope.getNext(); + visitEnterScope(enterScope, enterScope.getFirstChild()); + visitExpression(expr.getFirstChild(), 0); + addToken(Token.LEAVE_SCOPE); break; } diff --git a/rhino/src/main/java/org/mozilla/javascript/Constructable.java b/rhino/src/main/java/org/mozilla/javascript/Constructable.java index 28f7f2d7842..36e47736742 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Constructable.java +++ b/rhino/src/main/java/org/mozilla/javascript/Constructable.java @@ -16,4 +16,8 @@ public interface Constructable { * @return the allocated object */ Scriptable construct(Context cx, VarScope scope, Object[] args); + + default Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { + return construct(cx, s, args); + } } diff --git a/rhino/src/main/java/org/mozilla/javascript/ContextFactory.java b/rhino/src/main/java/org/mozilla/javascript/ContextFactory.java index b8f60c13707..6300382e134 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ContextFactory.java +++ b/rhino/src/main/java/org/mozilla/javascript/ContextFactory.java @@ -323,7 +323,7 @@ public final void initApplicationClassLoader(ClassLoader loader) { * perform the real call. In this way execution of any script happens inside this function. */ protected Object doTopCall( - Callable callable, Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Callable callable, Context cx, VarScope scope, Object thisObj, Object[] args) { Object result = callable.call(cx, scope, thisObj, args); return result instanceof ConsString ? result.toString() : result; } @@ -333,7 +333,7 @@ protected Object doTopCall( * 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(Script script, Context cx, VarScope scope, Scriptable thisObj) { + protected Object doTopCall(Script script, Context cx, VarScope scope, Object thisObj) { Object result = script.exec(cx, scope, thisObj); return result instanceof ConsString ? result.toString() : result; } diff --git a/rhino/src/main/java/org/mozilla/javascript/DeclarationScope.java b/rhino/src/main/java/org/mozilla/javascript/DeclarationScope.java index 1d9571fe169..9ddd57e833f 100644 --- a/rhino/src/main/java/org/mozilla/javascript/DeclarationScope.java +++ b/rhino/src/main/java/org/mozilla/javascript/DeclarationScope.java @@ -1,7 +1,7 @@ package org.mozilla.javascript; public class DeclarationScope extends ScopeObject { - private static final long serialVersionUID = -7471457301304454454L; + private static final long serialVersionUID = -7992031023451233550L; public DeclarationScope(VarScope parentScope) { super(parentScope); diff --git a/rhino/src/main/java/org/mozilla/javascript/Delegator.java b/rhino/src/main/java/org/mozilla/javascript/Delegator.java index ca7ed36146f..a706e020e14 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Delegator.java +++ b/rhino/src/main/java/org/mozilla/javascript/Delegator.java @@ -253,7 +253,7 @@ public boolean hasInstance(Scriptable instance) { * @see org.mozilla.javascript.Function#call */ @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { return ((Function) getDelegee()).call(cx, scope, thisObj, args); } @@ -286,4 +286,22 @@ public Scriptable construct(Context cx, VarScope scope, Object[] args) { } return ((Constructable) myDelegee).construct(cx, scope, args); } + + @Override + public Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { + Scriptable myDelegee = getDelegee(); + if (myDelegee == null) { + // this little trick allows us to declare prototype objects for Delegators + Delegator n = newInstance(); + Scriptable delegee; + if (args.length == 0) { + delegee = cx.newObject(s); + } else { + delegee = ScriptRuntime.toObject(cx, s, args[0]); + } + n.setDelegee(delegee); + return n; + } + return ((Constructable) myDelegee).construct(cx, nt, s, thisObj, args); + } } diff --git a/rhino/src/main/java/org/mozilla/javascript/ES6Generator.java b/rhino/src/main/java/org/mozilla/javascript/ES6Generator.java index 50c7d6a6046..9cc76c353bc 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ES6Generator.java +++ b/rhino/src/main/java/org/mozilla/javascript/ES6Generator.java @@ -6,10 +6,30 @@ package org.mozilla.javascript; -public final class ES6Generator extends ScriptableObject { - private static final long serialVersionUID = 1645892441041347273L; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.Symbol.Kind.REGULAR; - static final Object GENERATOR_TAG = "Generator"; +public final class ES6Generator extends ScriptableObject { + private static final long serialVersionUID = -1617667918827493330L; + + static final SymbolKey GENERATOR_TAG = new SymbolKey("GeneratorPrototype", REGULAR); + + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder(GENERATOR_TAG) + .withMethod(CTOR, "next", 1, ES6Generator::js_next) + .withMethod(CTOR, "return", 1, ES6Generator::js_return) + .withMethod(CTOR, "throw", 1, ES6Generator::js_throw) + .withMethod(CTOR, SymbolKey.ITERATOR, 0, ES6Generator::js_iterator) + .withProp( + CTOR, + SymbolKey.TO_STRING_TAG, + value("Generator", DONTENUM | READONLY)) + .build(); + } private JSFunction function; private Object savedState; @@ -18,33 +38,13 @@ public final class ES6Generator extends ScriptableObject { private State state = State.SUSPENDED_START; private Object delegee; - static ES6Generator init(TopLevel scope, boolean sealed) { - - ES6Generator prototype = new ES6Generator(); - if (scope != null) { - prototype.setParentScope(scope); - prototype.setPrototype(getObjectPrototype(scope)); - } + static ScriptableObject init(Context cx, TopLevel scope, boolean sealed) { - // Define prototype methods using LambdaFunction - LambdaFunction next = new LambdaFunction(scope, "next", 1, ES6Generator::js_next); - ScriptableObject.defineProperty(prototype, "next", next, DONTENUM); + NativeObject prototype = new NativeObject(); + DESCRIPTOR.populateGlobal(cx, scope, prototype, sealed); - LambdaFunction returnFunc = new LambdaFunction(scope, "return", 1, ES6Generator::js_return); - ScriptableObject.defineProperty(prototype, "return", returnFunc, DONTENUM); - - LambdaFunction throwFunc = new LambdaFunction(scope, "throw", 1, ES6Generator::js_throw); - ScriptableObject.defineProperty(prototype, "throw", throwFunc, DONTENUM); - - LambdaFunction iterator = - new LambdaFunction(scope, "[Symbol.iterator]", 0, ES6Generator::js_iterator); - prototype.defineProperty(SymbolKey.ITERATOR, iterator, DONTENUM); - - prototype.defineProperty(SymbolKey.TO_STRING_TAG, "Generator", DONTENUM | READONLY); - - if (sealed) { - prototype.sealObject(); - } + var iterCtor = (JSFunction) scope.get("Iterator", scope); + prototype.setPrototype((Scriptable) iterCtor.getPrototypeProperty()); // Need to access Generator prototype when constructing // Generator instances, but don't have a generator constructor @@ -75,8 +75,8 @@ public ES6Generator(VarScope scope, JSFunction function, Object savedState) { // If function.prototype is not an Object, use the intrinsic default prototype // Ref: Ecma 2026, 10.1.14 GetPrototypeFromConstructor step 4. // See test262: language/statements/generators/default-proto.js - ES6Generator prototype = - (ES6Generator) ScriptableObject.getTopScopeValue(top, GENERATOR_TAG); + ScriptableObject prototype = + (ScriptableObject) ScriptableObject.getTopScopeValue(top, GENERATOR_TAG); this.setPrototype(prototype); } } @@ -90,34 +90,38 @@ private static ES6Generator realThis(Object thisObj) { return LambdaConstructor.convertThisObject(thisObj, ES6Generator.class); } - private static Object js_return(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_return( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ES6Generator generator = realThis(thisObj); Object value = args.length >= 1 ? args[0] : Undefined.instance; if (generator.delegee == null) { - return generator.resumeAbruptLocal(cx, scope, NativeGenerator.GENERATOR_CLOSE, value); + return generator.resumeAbruptLocal(cx, s, NativeGenerator.GENERATOR_CLOSE, value); } - return generator.resumeDelegeeReturn(cx, scope, value); + return generator.resumeDelegeeReturn(cx, s, value); } - private static Object js_next(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_next( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ES6Generator generator = realThis(thisObj); Object value = args.length >= 1 ? args[0] : Undefined.instance; if (generator.delegee == null) { - return generator.resumeLocal(cx, scope, value); + return generator.resumeLocal(cx, s, value); } - return generator.resumeDelegee(cx, scope, value); + return generator.resumeDelegee(cx, s, value); } - private static Object js_throw(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_throw( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ES6Generator generator = realThis(thisObj); Object value = args.length >= 1 ? args[0] : Undefined.instance; if (generator.delegee == null) { - return generator.resumeAbruptLocal(cx, scope, NativeGenerator.GENERATOR_THROW, value); + return generator.resumeAbruptLocal(cx, s, NativeGenerator.GENERATOR_THROW, value); } - return generator.resumeDelegeeThrow(cx, scope, value); + return generator.resumeDelegeeThrow(cx, s, value); } - private static Object js_iterator(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_iterator( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return thisObj; } @@ -230,7 +234,7 @@ private Scriptable resumeDelegeeReturn(Context cx, VarScope scope, Object value) } } - private Scriptable resumeLocal(Context cx, VarScope scope, Object value) { + Scriptable resumeLocal(Context cx, VarScope scope, Object value) { if (state == State.COMPLETED) { return ES6Iterator.makeIteratorResult(cx, scope, Boolean.TRUE); } @@ -304,7 +308,7 @@ private Scriptable resumeLocal(Context cx, VarScope scope, Object value) { return result; } - private Scriptable resumeAbruptLocal(Context cx, VarScope scope, int op, Object value) { + Scriptable resumeAbruptLocal(Context cx, VarScope scope, int op, Object value) { if (state == State.EXECUTING) { throw ScriptRuntime.typeErrorById("msg.generator.executing"); } diff --git a/rhino/src/main/java/org/mozilla/javascript/ES6Iterator.java b/rhino/src/main/java/org/mozilla/javascript/ES6Iterator.java index cec23c0bb74..60f7b3cb980 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ES6Iterator.java +++ b/rhino/src/main/java/org/mozilla/javascript/ES6Iterator.java @@ -6,6 +6,9 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; + public abstract class ES6Iterator extends ScriptableObject { private static final long serialVersionUID = 2438373029140003950L; @@ -16,35 +19,26 @@ public abstract class ES6Iterator extends ScriptableObject { public static final String VALUE_PROPERTY = "value"; public static final String RETURN_METHOD = "return"; - protected static void init( - TopLevel scope, boolean sealed, ScriptableObject prototype, String tag) { - if (scope != null) { - prototype.setParentScope(scope); - prototype.setPrototype(getObjectPrototype(scope)); - } - - // Define prototype methods using LambdaFunction - LambdaFunction next = new LambdaFunction(scope, NEXT_METHOD, 0, ES6Iterator::js_next); - ScriptableObject.defineProperty(prototype, NEXT_METHOD, next, DONTENUM); - - LambdaFunction iterator = - new LambdaFunction(scope, "[Symbol.iterator]", 1, ES6Iterator::js_iterator); - prototype.defineProperty(SymbolKey.ITERATOR, iterator, DONTENUM); - - prototype.defineProperty( - SymbolKey.TO_STRING_TAG, prototype.getClassName(), DONTENUM | READONLY); - - if (sealed) { - prototype.sealObject(); - } + public static ClassDescriptor makeDescriptor(String name, String tag) { + // Need a way to associate the built object with the tag. We + // kind of need this in general, and at the top level, but we + // can bodge it for now. + return new ClassDescriptor.Builder(name) + .withMethod(CTOR, "next", 0, ES6Iterator::js_next) + .withMethod(CTOR, SymbolKey.ITERATOR, 1, ES6Iterator::js_iterator) + .withProp(CTOR, SymbolKey.TO_STRING_TAG, value(tag, DONTENUM | READONLY)) + .build(); + } - // Need to access Iterator prototype when constructing - // Iterator instances, but don't have a iterator constructor - // to use to find the prototype. Use the "associateValue" - // approach instead. - if (scope != null) { - scope.associateValue(tag, prototype); - } + public static void initialize( + ClassDescriptor desc, + Context cx, + TopLevel scope, + ScriptableObject obj, + boolean sealed, + String name) { + var global = desc.populateGlobal(cx, scope, obj, sealed); + scope.associateValue(name, global); } protected boolean exhausted = false; @@ -67,12 +61,14 @@ private static ES6Iterator realThis(Object thisObj) { return LambdaConstructor.convertThisObject(thisObj, ES6Iterator.class); } - private static Object js_next(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_next( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ES6Iterator iterator = realThis(thisObj); - return iterator.next(cx, scope); + return iterator.next(cx, s); } - private static Object js_iterator(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_iterator( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return thisObj; } diff --git a/rhino/src/main/java/org/mozilla/javascript/Function.java b/rhino/src/main/java/org/mozilla/javascript/Function.java index 039d1b639c0..73970a1fa1b 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Function.java +++ b/rhino/src/main/java/org/mozilla/javascript/Function.java @@ -29,7 +29,7 @@ public interface Function extends Scriptable, Callable, Constructable { * @return the result of the call */ @Override - Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args); + Object call(Context cx, VarScope scope, Object thisObj, Object[] args); /** * Call the function as a constructor. @@ -46,6 +46,9 @@ public interface Function extends Scriptable, Callable, Constructable { @Override Scriptable construct(Context cx, VarScope scope, Object[] args); + @Override + Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args); + /** * Return the scope in which this function was declared or closed over. This is the * "[[Environment]]" defined in https://tc39.es/ecma262/#sec-ecmascript-function-objects. @@ -61,4 +64,9 @@ default VarScope getDeclarationScope() { default boolean isConstructor() { return true; } + + /** Returns whether this is an async function. */ + default boolean isAsync() { + return false; + } } diff --git a/rhino/src/main/java/org/mozilla/javascript/FunctionObject.java b/rhino/src/main/java/org/mozilla/javascript/FunctionObject.java index bdc7f4c2683..ca0495492ae 100644 --- a/rhino/src/main/java/org/mozilla/javascript/FunctionObject.java +++ b/rhino/src/main/java/org/mozilla/javascript/FunctionObject.java @@ -16,7 +16,7 @@ import java.lang.reflect.Modifier; public class FunctionObject extends BaseFunction { - private static final long serialVersionUID = -5332312783643935019L; + private static final long serialVersionUID = 8880062939740158370L; /** * Create a JavaScript function object from a Java method. @@ -77,6 +77,7 @@ public class FunctionObject extends BaseFunction { * @see org.mozilla.javascript.Scriptable */ public FunctionObject(String name, Member methodOrConstructor, VarScope scope) { + super(scope); if (methodOrConstructor instanceof Constructor) { member = new MemberBox(scope, (Constructor) methodOrConstructor); isStatic = true; // well, doesn't take a 'this' @@ -353,7 +354,7 @@ public static Object convertArg(Context cx, VarScope scope, Object arg, Class * @see org.mozilla.javascript.Function#call( Context, VarScope, Scriptable, Object[]) */ @Override - public Object call(Context cx, VarScope scope, Scriptable thisArg, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisArg, Object[] args) { Object result; boolean checkMethodResult = false; int argsLength = args.length; diff --git a/rhino/src/main/java/org/mozilla/javascript/FunctionScope.java b/rhino/src/main/java/org/mozilla/javascript/FunctionScope.java index f2ad393e45f..ed4017e7d2a 100644 --- a/rhino/src/main/java/org/mozilla/javascript/FunctionScope.java +++ b/rhino/src/main/java/org/mozilla/javascript/FunctionScope.java @@ -1,7 +1,7 @@ package org.mozilla.javascript; public class FunctionScope extends DeclarationScope { - private static final long serialVersionUID = -7471457301304454454L; + private static final long serialVersionUID = 4760825497832652202L; public FunctionScope(ScopeObject parentScope) { super(parentScope); diff --git a/rhino/src/main/java/org/mozilla/javascript/IRFactory.java b/rhino/src/main/java/org/mozilla/javascript/IRFactory.java index 50e9cc738b1..4e64efed97b 100644 --- a/rhino/src/main/java/org/mozilla/javascript/IRFactory.java +++ b/rhino/src/main/java/org/mozilla/javascript/IRFactory.java @@ -18,6 +18,7 @@ import org.mozilla.javascript.ast.Assignment; import org.mozilla.javascript.ast.AstNode; import org.mozilla.javascript.ast.AstRoot; +import org.mozilla.javascript.ast.AwaitExpression; import org.mozilla.javascript.ast.BigIntLiteral; import org.mozilla.javascript.ast.Block; import org.mozilla.javascript.ast.BreakStatement; @@ -198,6 +199,7 @@ private Node transform(AstNode node) { case Token.NULL: case Token.UNDEFINED: case Token.DEBUGGER: + case Token.NEW_TARGET: return transformLiteral(node); case Token.SUPER: parser.setRequiresActivation(); @@ -235,6 +237,8 @@ private Node transform(AstNode node) { case Token.YIELD: case Token.YIELD_STAR: return transformYield((Yield) node); + case Token.AWAIT: + return transformAwait((AwaitExpression) node); default: if (node instanceof ExpressionStatement) { return transformExprStmt((ExpressionStatement) node); @@ -650,6 +654,14 @@ private Node transformFunction(FunctionNode fn) { Node destructuring = (Node) fn.getProp(Node.DESTRUCTURING_PARAMS); fn.removeProp(Node.DESTRUCTURING_PARAMS); + // Async non-generator functions use generator machinery internally to implement + // await: each await expression becomes a yield point. Mark the function as a + // generator now so that default-parameter and return-statement handling below + // uses the correct (generator) code paths. + if (fn.isAsync() && !fn.isES6Generator()) { + fn.setIsGenerator(); + } + int lineno = fn.getBody().getLineno(), column = fn.getBody().getColumn(); ++parser.nestingOfFunction; // only for body, not params Node body = transform(fn.getBody()); @@ -1384,6 +1396,12 @@ private Node transformYield(Yield node) { return new Node(node.getType(), node.getLineno(), node.getColumn()); } + private Node transformAwait(AwaitExpression node) { + Node kid = node.getValue() == null ? null : transform(node.getValue()); + if (kid != null) return new Node(Token.AWAIT, kid, node.getLineno(), node.getColumn()); + return new Node(Token.AWAIT, node.getLineno(), node.getColumn()); + } + private Node transformSpread(Spread node) { Node kid = transform(node.getExpression()); return new Node(node.getType(), kid, node.getLineno(), node.getColumn()); @@ -1892,7 +1910,7 @@ private Node createTryCatchFinally( // but prefix it with LEAVEWITH since try..catch produces // "with"code in order to limit the scope of the exception // object. - catchStatement.addChildToBack(new Node(Token.LEAVEWITH)); + catchStatement.addChildToBack(new Node(Token.LEAVE_SCOPE)); catchStatement.addChildToBack(makeJump(Token.GOTO, endCatch)); // Create condition "if" when present @@ -1911,13 +1929,9 @@ private Node createTryCatchFinally( catchScope.putIntProp(Node.CATCH_SCOPE_PROP, scopeIndex); catchScopeBlock.addChildToBack(catchScope); - // Add with statement based on catch scope object - catchScopeBlock.addChildToBack( - createWith( - createUseLocal(catchScopeBlock), - condStmt, - catchLineno, - catchColumn)); + parser.setRequiresActivation(); + catchScopeBlock.addChildToBack(condStmt); + catchScopeBlock.addChildToBack(new Node(Token.LEAVE_SCOPE)); // move to next cb cb = cb.getNext(); @@ -1962,7 +1976,7 @@ private Node createWith(Node obj, Node body, int lineno, int column) { result.addChildToBack(new Node(Token.ENTERWITH, obj)); Node bodyNode = new Node(Token.WITH, body, lineno, column); result.addChildrenToBack(bodyNode); - result.addChildToBack(new Node(Token.LEAVEWITH)); + result.addChildToBack(new Node(Token.LEAVE_SCOPE)); return result; } diff --git a/rhino/src/main/java/org/mozilla/javascript/IdFunctionObject.java b/rhino/src/main/java/org/mozilla/javascript/IdFunctionObject.java index e81379675b7..cf3eec2e034 100644 --- a/rhino/src/main/java/org/mozilla/javascript/IdFunctionObject.java +++ b/rhino/src/main/java/org/mozilla/javascript/IdFunctionObject.java @@ -11,9 +11,10 @@ import java.util.Objects; public class IdFunctionObject extends BaseFunction { - private static final long serialVersionUID = -5332312783643935019L; + private static final long serialVersionUID = 4323463961654640261L; public IdFunctionObject(IdFunctionCall idcall, Object tag, int id, int arity) { + super(null); if (arity < 0) throw new IllegalArgumentException(); this.idcall = idcall; @@ -81,17 +82,17 @@ public Scriptable getPrototype() { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { // We need to do some sneakiness here for constructors... return idcall.execIdCall(this, cx, scope, getThisObj(thisObj), args); } - public final Scriptable getThisObj(Scriptable thisObj) { + public final Scriptable getThisObj(Object thisObj) { if (useCallAsConstructor && (thisObj == null || Undefined.isUndefined(thisObj))) { var res = ScriptableObject.getTopLevelScope(getDeclarationScope()).getGlobalThis(); return res; } else { - return thisObj; + return ScriptRuntime.toObject(getDeclarationScope(), thisObj); } } diff --git a/rhino/src/main/java/org/mozilla/javascript/Interpreter.java b/rhino/src/main/java/org/mozilla/javascript/Interpreter.java index 5d2e460f82a..1cc613c7fbd 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Interpreter.java +++ b/rhino/src/main/java/org/mozilla/javascript/Interpreter.java @@ -75,7 +75,8 @@ private static class CallFrame implements Cloneable, Serializable { final boolean useActivation; boolean isContinuationsTopFrame; - final Scriptable thisObj; + final Object thisObj; + final Object newTarget; // The values that change during interpretation @@ -93,7 +94,8 @@ private static class CallFrame implements Cloneable, Serializable { CallFrame( Context cx, - Scriptable thisObj, + Object thisObj, + Object newTarget, ScriptOrFn fnOrScript, InterpreterData code, CallFrame parentFrame, @@ -116,6 +118,7 @@ private static class CallFrame implements Cloneable, Serializable { this.fnOrScript = fnOrScript; varSource = this; this.thisObj = thisObj; + this.newTarget = newTarget; this.parentFrame = parentFrame; if (parentFrame == null) { @@ -183,6 +186,7 @@ private CallFrame( isContinuationsTopFrame = original.isContinuationsTopFrame; thisObj = original.thisObj; + newTarget = original.newTarget; result = original.result; resultDbl = original.resultDbl; @@ -235,6 +239,7 @@ private CallFrame( isContinuationsTopFrame = original.isContinuationsTopFrame; thisObj = original.thisObj; + newTarget = original.newTarget; result = original.result; resultDbl = original.resultDbl; @@ -304,7 +309,7 @@ void initializeArgs( // creation // Ref: Ecma 2026, 10.2.11, FunctionDeclarationInstantiation - if (desc.getFunctionCount() != 0 && !desc.isES6Generator()) { + if (desc.getFunctionCount() != 0 && !desc.isES6Generator() && !desc.isAsync()) { if (desc.getFunctionType() != 0 && !desc.requiresActivationFrame()) Kit.codeBug(); for (int i = 0; i < desc.getFunctionCount(); i++) { JSDescriptor fdesc = desc.getFunction(i); @@ -1166,8 +1171,9 @@ static Object interpret( InterpreterData idata, Context cx, VarScope scope, - Scriptable thisObj, - Object[] args) { + Object thisObj, + Object[] args, + Object newTarget) { if (!ScriptRuntime.hasTopCall(cx)) Kit.codeBug(); var desc = ifun.getDescriptor(); @@ -1215,7 +1221,8 @@ static Object interpret( args.length, ifun, idata, - null); + null, + newTarget); frame.isContinuationsTopFrame = cx.isContinuationsTopCall; cx.isContinuationsTopCall = false; @@ -1511,11 +1518,13 @@ static void dumpJumpTarget(String tname, ICodeDumpContext ctx) { instructionObjs[base + Token.THIS] = new DoThis(); instructionObjs[base + Token.SUPER] = new DoSuper(); instructionObjs[base + Token.THISFN] = new DoThisFunction(); + instructionObjs[base + Token.NEW_TARGET] = new DoNewTarget(); instructionObjs[base + Token.FALSE] = new DoFalse(); instructionObjs[base + Token.TRUE] = new DoTrue(); instructionObjs[base + Icode_UNDEF] = new DoUndef(); instructionObjs[base + Token.ENTERWITH] = new DoEnterWith(); - instructionObjs[base + Token.LEAVEWITH] = new DoLeaveWith(); + instructionObjs[base + Token.ENTER_SCOPE] = new DoEnterScope(); + instructionObjs[base + Token.LEAVE_SCOPE] = new DoLeaveScope(); instructionObjs[base + Token.CATCH_SCOPE] = new DoCatchScope(); instructionObjs[base + Token.ENUM_INIT_KEYS] = new DoEnumInit(); instructionObjs[base + Token.ENUM_INIT_VALUES] = new DoEnumInit(); @@ -1941,11 +1950,17 @@ private static void generatorCreate(Context cx, CallFrame frame) { CallFrame generatorFrame = captureFrameForGenerator(frame); generatorFrame.frozen = true; if (cx.getLanguageVersion() >= Context.VERSION_ES6) { - frame.result = - new ES6Generator( - frame.scope, - (JSFunction) generatorFrame.fnOrScript, - generatorFrame); + JSFunction fn = (JSFunction) generatorFrame.fnOrScript; + ES6Generator gen = new ES6Generator(frame.scope, fn, generatorFrame); + if (fn.isAsync() && !fn.isGeneratorFunction()) { + // Async non-generator function: drive via Promise runner. + // isGeneratorFunction() returns descriptor.isES6Generator(), which is + // false for async non-generators (we only called setIsGenerator(), not + // setIsES6Generator(), in IRFactory). + frame.result = NativePromise.createAsyncFunctionPromise(cx, frame.scope, gen); + } else { + frame.result = gen; + } } else { frame.result = new NativeGenerator( @@ -1979,7 +1994,10 @@ private static Object freezeGenerator( frame.resultDbl = frame.sDbl[state.stackTop]; frame.savedStackTop = state.stackTop; frame.pc--; // we want to come back here when we resume - ScriptRuntime.exitActivationFunction(cx); + var desc = frame.fnOrScript.getDescriptor(); + if (!desc.isES6Generator() && !desc.isAsync()) { + ScriptRuntime.exitActivationFunction(cx); + } final Object result = (frame.result != DOUBLE_MARK) ? frame.result @@ -3407,7 +3425,7 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { // Check if the lookup result is a function and throw if it's not // must not be done sooner according to the spec Callable fun = result.getCallable(); - Scriptable funThisObj = result.getThis(); + Object funThisObj = result.getThis(); Scriptable funHomeObj = (fun instanceof BaseFunction) ? ((BaseFunction) fun).getHomeObject() : null; if (op == Icode_CALL_ON_SUPER) { @@ -3435,82 +3453,72 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { // if the function is already an interpreted function, which // should be the majority of cases. for (; ; ) { - if (fun instanceof KnownBuiltInFunction) { - KnownBuiltInFunction kfun = (KnownBuiltInFunction) fun; - // Bug 405654 -- make the best effort to keep - // Function.apply and Function.call within this - // interpreter loop invocation - if (BaseFunction.isApplyOrCall(kfun)) { - // funThisObj becomes fun - fun = ScriptRuntime.getCallable(funThisObj); - // first arg becomes thisObj - funThisObj = - getApplyThis( - cx, + if (BaseFunction.isApplyOrCall(fun)) { + // funThisObj becomes fun + var target = ScriptRuntime.getCallable(funThisObj); + // first arg becomes thisObj + funThisObj = + getApplyThis( + cx, + stack, + sDbl, + boundArgs, + state.stackTop + 1, + state.indexReg, + (Function) target, + frame); + if (BaseFunction.isApply(fun)) { + // Apply: second argument after new "this" + // should be array-like + // and we'll spread its elements on the stack + final Object[] callArgs; + if (blen > 1) { + callArgs = ScriptRuntime.getApplyArguments(cx, boundArgs[1]); + } else if (state.indexReg < 2) { + callArgs = ScriptRuntime.emptyArgs; + } else { + callArgs = + ScriptRuntime.getApplyArguments( + cx, stack[state.stackTop - blen + 2]); + } + + int alen = callArgs.length; + // We're coming from the outside, so this + // is replacing any bound args we might + // have had already. + boundArgs = callArgs; + blen = alen; + state.indexReg = alen; + } else { + // Call: shift args left, starting from 2nd + if (state.indexReg > 0) { + if (state.indexReg > 1 && blen == 0) { + System.arraycopy( + stack, + state.stackTop + 2, stack, + state.stackTop + 1, + state.indexReg - 1); + System.arraycopy( + sDbl, + state.stackTop + 2, sDbl, - boundArgs, state.stackTop + 1, - state.indexReg, - (Function) fun, - frame); - if (BaseFunction.isApply(kfun)) { - // Apply: second argument after new "this" - // should be array-like - // and we'll spread its elements on the stack - final Object[] callArgs; - if (blen > 1) { - callArgs = ScriptRuntime.getApplyArguments(cx, boundArgs[1]); - } else if (state.indexReg < 2) { - callArgs = ScriptRuntime.emptyArgs; + state.indexReg - 1); + } else if (state.indexReg > 1) { + Object[] newBArgs = new Object[boundArgs.length - 1]; + System.arraycopy(boundArgs, 1, newBArgs, 0, boundArgs.length - 1); + boundArgs = newBArgs; + blen = newBArgs.length; } else { - callArgs = - ScriptRuntime.getApplyArguments( - cx, stack[state.stackTop - blen + 2]); - } - - int alen = callArgs.length; - // We're coming from the outside, so this - // is replacing any bound args we might - // have had already. - boundArgs = callArgs; - blen = alen; - state.indexReg = alen; - } else { - // Call: shift args left, starting from 2nd - if (state.indexReg > 0) { - if (state.indexReg > 1 && blen == 0) { - System.arraycopy( - stack, - state.stackTop + 2, - stack, - state.stackTop + 1, - state.indexReg - 1); - System.arraycopy( - sDbl, - state.stackTop + 2, - sDbl, - state.stackTop + 1, - state.indexReg - 1); - } else if (state.indexReg > 1) { - Object[] newBArgs = new Object[boundArgs.length - 1]; - System.arraycopy( - boundArgs, 1, newBArgs, 0, boundArgs.length - 1); - boundArgs = newBArgs; - blen = newBArgs.length; - } else { - // Bound args is 1 long. - boundArgs = new Object[0]; - blen = 0; - } - state.indexReg--; + // Bound args is 1 long. + boundArgs = new Object[0]; + blen = 0; } + state.indexReg--; } - } else { - // Some other IdFunctionObject we don't know how to - // reduce. - break; } + fun = target; } else if (fun instanceof LambdaConstructor) { break; } else if (fun instanceof LambdaFunction) { @@ -3555,8 +3563,9 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { if (fun instanceof JSFunction && ((JSFunction) fun).getDescriptor().getCode() instanceof InterpreterData) { JSFunction ifun = (JSFunction) fun; - JSDescriptor desc = ifun.getDescriptor(); - InterpreterData idata = (InterpreterData) desc.getCode(); + + JSDescriptor desc = ifun.getDescriptor(); + var idata = (InterpreterData) desc.getCode(); if (frame.fnOrScript.getDescriptor().getSecurityDomain() == desc.getSecurityDomain()) { CallFrame callParentFrame = frame; @@ -3598,7 +3607,8 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { state.indexReg, ifun, idata, - callParentFrame); + callParentFrame, + ifun.getLexicalNewTarget()); if (op != Icode_TAIL_CALL) { frame.savedStackTop = state.stackTop; frame.savedCallOp = op; @@ -3626,8 +3636,9 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { return BREAK_WITHOUT_EXTENSION; } - if (fun instanceof IdFunctionObject) { - IdFunctionObject ifun = (IdFunctionObject) fun; + if (fun instanceof JSFunction) { + var ifun = (JSFunction) fun; + if (NativeContinuation.isContinuationConstructor(ifun)) { frame.stack[state.stackTop] = captureContinuation(cx, frame.parentFrame, false); return null; @@ -3672,8 +3683,9 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { if (lhs instanceof JSFunction && ((JSFunction) lhs).getConstructor() instanceof InterpreterData) { JSFunction f = (JSFunction) lhs; - JSDescriptor desc = f.getDescriptor(); - InterpreterData idata = (InterpreterData) desc.getConstructor(); + + JSDescriptor desc = f.getDescriptor(); + var idata = (InterpreterData) desc.getConstructor(); if (frame.fnOrScript.getDescriptor().getSecurityDomain() == desc.getSecurityDomain()) { if (cx.getLanguageVersion() >= Context.VERSION_ES6 @@ -3698,7 +3710,8 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { state.indexReg, f, idata, - frame); + frame, + lhs); frame.stack[state.stackTop] = newInstance; frame.savedStackTop = state.stackTop; @@ -3706,20 +3719,21 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { return new StateContinueResult(calleeFrame, state.indexReg); } } - if (!(lhs instanceof Constructable)) { - if (lhs == DOUBLE_MARK) lhs = ScriptRuntime.wrapNumber(frame.sDbl[state.stackTop]); - throw ScriptRuntime.notFunctionError(lhs); - } - Constructable ctor = (Constructable) lhs; + if (lhs instanceof JSFunction) { + var f = (JSFunction) lhs; - if (ctor instanceof IdFunctionObject) { - IdFunctionObject ifun = (IdFunctionObject) ctor; - if (NativeContinuation.isContinuationConstructor(ifun)) { + if (NativeContinuation.isContinuationConstructor(f)) { frame.stack[state.stackTop] = captureContinuation(cx, frame.parentFrame, false); return null; } } + if (!(lhs instanceof Constructable)) { + if (lhs == DOUBLE_MARK) lhs = ScriptRuntime.wrapNumber(frame.sDbl[state.stackTop]); + throw ScriptRuntime.notFunctionError(lhs); + } + Constructable ctor = (Constructable) lhs; + Object[] outArgs = getArgsArray(frame.stack, frame.sDbl, state.stackTop + 1, state.indexReg); frame.stack[state.stackTop] = ctor.construct(cx, frame.scope, outArgs); @@ -4099,6 +4113,14 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { } } + private static class DoNewTarget extends InstructionClass { + @Override + NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { + frame.stack[++state.stackTop] = frame.newTarget; + return null; + } + } + private static class DoFalse extends InstructionClass { @Override NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { @@ -4134,10 +4156,19 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { } } - private static class DoLeaveWith extends InstructionClass { + private static class DoEnterScope extends InstructionClass { @Override NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { - frame.scope = ScriptRuntime.leaveWith(frame.scope); + frame.scope = new LocalScope(frame.scope); + frame.stack[++state.stackTop] = frame.scope; + return null; + } + } + + private static class DoLeaveScope extends InstructionClass { + @Override + NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { + frame.scope = ScriptRuntime.leaveScope(frame.scope); return null; } } @@ -4154,15 +4185,17 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { boolean afterFirstScope = (frame.idata.itsICode[frame.pc] != 0); Throwable caughtException = (Throwable) frame.stack[state.stackTop + 1]; - Scriptable lastCatchScope; + VarScope lastCatchScope; if (!afterFirstScope) { lastCatchScope = null; } else { - lastCatchScope = (Scriptable) frame.stack[state.indexReg]; + lastCatchScope = (VarScope) frame.stack[state.indexReg]; } - frame.stack[state.indexReg] = + VarScope catchScope = ScriptRuntime.newCatchScope( caughtException, lastCatchScope, state.stringReg, cx, frame.scope); + frame.stack[state.indexReg] = catchScope; + frame.scope = catchScope; ++frame.pc; return null; } @@ -4183,7 +4216,9 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) { state.indexReg += frame.idata.itsMaxVars; int enumType = op == Token.ENUM_INIT_KEYS - ? ScriptRuntime.ENUMERATE_KEYS + ? cx.getLanguageVersion() <= Context.VERSION_1_8 + ? ScriptRuntime.ENUMERATE_KEYS + : ScriptRuntime.ENUMERATE_KEYS_NO_ITERATOR : op == Token.ENUM_INIT_VALUES ? ScriptRuntime.ENUMERATE_VALUES : op == Token.ENUM_INIT_VALUES_IN_ORDER @@ -5019,7 +5054,7 @@ private static Scriptable getApplyThis( private static CallFrame initFrame( Context cx, VarScope callerScope, - Scriptable thisObj, + Object thisObj, Scriptable homeObj, Object[] args, double[] argsDbl, @@ -5028,11 +5063,13 @@ private static CallFrame initFrame( int argCount, ScriptOrFn fnOrScript, InterpreterData code, - CallFrame parentFrame) { + CallFrame parentFrame, + Object newTarget) { CallFrame frame = new CallFrame( cx, thisObj, + newTarget, fnOrScript, code, parentFrame, @@ -5047,7 +5084,8 @@ private static CallFrame initFrame( private static void enterFrame( Context cx, CallFrame frame, Object[] args, boolean continuationRestart) { - boolean usesActivation = frame.fnOrScript.getDescriptor().requiresActivationFrame(); + var desc = frame.fnOrScript.getDescriptor(); + boolean usesActivation = desc.requiresActivationFrame(); boolean isDebugged = frame.debuggerFrame != null; if (usesActivation) { VarScope scope = frame.scope; @@ -5063,7 +5101,7 @@ private static void enterFrame( // block ("catch" implicitly uses WithScope to create a scope // to expose the exception variable). for (; ; ) { - if (scope instanceof WithScope) { + if (!(scope instanceof NativeCall)) { scope = scope.getParentScope(); if (scope == null || (frame.parentFrame != null @@ -5083,14 +5121,22 @@ private static void enterFrame( if (isDebugged) { frame.debuggerFrame.onEnter(cx, scope, frame.thisObj, args); } - ScriptRuntime.enterActivationFunction(cx, scope); + if (!(desc.isStrict() && cx.getLanguageVersion() >= Context.VERSION_ES6) + && !desc.isES6Generator() + && !desc.isAsync()) { + ScriptRuntime.enterActivationFunction(cx, scope); + } } else if (isDebugged) { frame.debuggerFrame.onEnter(cx, new DebugScope(frame), frame.thisObj, args); } } private static void exitFrame(Context cx, CallFrame frame, Object throwable) { - if (frame.fnOrScript.getDescriptor().requiresActivationFrame()) { + var desc = frame.fnOrScript.getDescriptor(); + if (desc.requiresActivationFrame() + && !(desc.isStrict() && cx.getLanguageVersion() >= Context.VERSION_ES6) + && !desc.isES6Generator() + && !desc.isAsync()) { ScriptRuntime.exitActivationFunction(cx); } @@ -5278,7 +5324,8 @@ private static JSFunction createClosure(Context cx, CallFrame frame, int index) var desc = frame.fnOrScript.getDescriptor().getFunction(index); boolean isArrow = desc.getFunctionType() == FunctionNode.ARROW_FUNCTION; var homeObject = isArrow ? frame.fnOrScript.getHomeObject() : null; - JSFunction f = new JSFunction(cx, frame.scope, desc, frame.thisObj, homeObject); + var newTarget = isArrow ? frame.newTarget : Undefined.instance; + JSFunction f = new JSFunction(cx, frame.scope, desc, frame.thisObj, newTarget, homeObject); return f; } @@ -5286,7 +5333,8 @@ private static JSFunction createMethod( Context cx, CallFrame frame, int index, Scriptable homeObject) { var desc = frame.fnOrScript.getDescriptor().getFunction(index); boolean isArrow = desc.getFunctionType() == FunctionNode.ARROW_FUNCTION; - JSFunction f = new JSFunction(cx, frame.scope, desc, frame.thisObj, homeObject); + var newTarget = isArrow ? frame.newTarget : Undefined.instance; + JSFunction f = new JSFunction(cx, frame.scope, desc, frame.thisObj, newTarget, homeObject); return f; } } diff --git a/rhino/src/main/java/org/mozilla/javascript/InterpreterData.java b/rhino/src/main/java/org/mozilla/javascript/InterpreterData.java index a305fdf4978..1c33d4c8571 100644 --- a/rhino/src/main/java/org/mozilla/javascript/InterpreterData.java +++ b/rhino/src/main/java/org/mozilla/javascript/InterpreterData.java @@ -101,7 +101,7 @@ public Object execute( VarScope scope, Object thisObj, Object[] args) { - return Interpreter.interpret(executableObject, this, cx, scope, (Scriptable) thisObj, args); + return Interpreter.interpret(executableObject, this, cx, scope, thisObj, args, newTarget); } @Override diff --git a/rhino/src/main/java/org/mozilla/javascript/JSCode.java b/rhino/src/main/java/org/mozilla/javascript/JSCode.java index 84fc5450e49..92e218782e9 100644 --- a/rhino/src/main/java/org/mozilla/javascript/JSCode.java +++ b/rhino/src/main/java/org/mozilla/javascript/JSCode.java @@ -35,7 +35,7 @@ public JSCode build() { private static class NotCallable extends JSCode implements Serializable { - private static final long serialVersionUID = 2691205302914111400L; + private static final long serialVersionUID = -31340315773728063L; @Override public Object execute( diff --git a/rhino/src/main/java/org/mozilla/javascript/JSDescriptor.java b/rhino/src/main/java/org/mozilla/javascript/JSDescriptor.java index a05b05e430f..e85fa70b1a2 100644 --- a/rhino/src/main/java/org/mozilla/javascript/JSDescriptor.java +++ b/rhino/src/main/java/org/mozilla/javascript/JSDescriptor.java @@ -30,6 +30,8 @@ public final class JSDescriptor> implements Serializable private static final int REQUIRES_ACTIVATION_FRAME_FLAG = 1 << 10; private static final int REQUIRES_ARGUMENT_OBJECT_FLAG = 1 << 11; private static final int DECLARED_AS_FUNCTION_EXPRESSION_FLAG = 1 << 12; + private static final int DERIVED_CONSTRUCTOR_FLAG = 1 << 13; + private static final int IS_ASYNC_FLAG = 1 << 14; private final JSCode code; private final JSCode constructor; @@ -79,6 +81,8 @@ public JSDescriptor( boolean requiresActivationFrame, boolean requiresArgumentObject, boolean declaredAsFunctionExpression, + boolean derivedConstructor, + boolean isAsync, SecurityController securityController, Object securityDomain, int functionType) { @@ -102,6 +106,8 @@ public JSDescriptor( flags = flags | (requiresActivationFrame ? REQUIRES_ACTIVATION_FRAME_FLAG : 0); flags = flags | (requiresArgumentObject ? REQUIRES_ARGUMENT_OBJECT_FLAG : 0); flags = flags | (declaredAsFunctionExpression ? DECLARED_AS_FUNCTION_EXPRESSION_FLAG : 0); + flags = flags | (derivedConstructor ? DERIVED_CONSTRUCTOR_FLAG : 0); + flags = flags | (isAsync ? IS_ASYNC_FLAG : 0); this.flags = flags; this.sourceFile = sourceFile; @@ -152,6 +158,10 @@ public boolean isES6Generator() { return (flags & IS_ES6_GENERATOR_FLAG) != 0; } + public boolean isAsync() { + return (flags & IS_ASYNC_FLAG) != 0; + } + public boolean isShorthand() { return (flags & IS_SHORTHAND_FLAG) != 0; } @@ -297,6 +307,7 @@ public static class Builder> { public boolean isScript; public boolean isTopLevel; public boolean isES6Generator; + public boolean isAsync; public boolean isShorthand; public boolean hasPrototype; public boolean hasLexicalThis; @@ -385,6 +396,8 @@ private JSDescriptor build(JSDescriptor parent, Consumer> requiresActivationFrame, requiresArgumentObject, declaredAsFunctionExpression, + false, + isAsync, securityController, securityDomain, functionType); diff --git a/rhino/src/main/java/org/mozilla/javascript/JSFunction.java b/rhino/src/main/java/org/mozilla/javascript/JSFunction.java index a0816b1feb5..1c6c4ebd8ab 100644 --- a/rhino/src/main/java/org/mozilla/javascript/JSFunction.java +++ b/rhino/src/main/java/org/mozilla/javascript/JSFunction.java @@ -10,19 +10,24 @@ */ public class JSFunction extends BaseFunction implements ScriptOrFn { private final JSDescriptor descriptor; - private final Scriptable lexicalThis; + private final Object lexicalThis; + private final Object lexicalNewTarget; private final Scriptable homeObject; public JSFunction( Context cx, VarScope scope, JSDescriptor descriptor, - Scriptable lexicalThis, + Object lexicalThis, + Object lexicalNewTarget, Scriptable homeObject) { + super(scope); this.descriptor = descriptor; this.lexicalThis = lexicalThis; + this.lexicalNewTarget = lexicalNewTarget; this.homeObject = homeObject; - ScriptRuntime.setFunctionProtoAndParent(this, cx, scope, descriptor.isES6Generator()); + ScriptRuntime.setFunctionProtoAndParent( + this, cx, scope, descriptor.isES6Generator(), descriptor.isAsync()); if (!descriptor.isShorthand()) { setupDefaultPrototype(scope); } @@ -32,9 +37,12 @@ public JSFunction( VarScope scope, JSDescriptor descriptor, Scriptable lexicalThis, + Object lexicalNewTarget, Scriptable homeObject) { + super(scope); this.descriptor = descriptor; this.lexicalThis = lexicalThis; + this.lexicalNewTarget = lexicalNewTarget; this.homeObject = homeObject; setParentScope(scope); setPrototype(ScriptableObject.getFunctionPrototype(scope)); @@ -91,6 +99,11 @@ protected boolean isGeneratorFunction() { return descriptor.isES6Generator(); } + @Override + public boolean isAsync() { + return descriptor.isAsync(); + } + @Override public int getLength() { return descriptor.getArity(); @@ -136,33 +149,36 @@ JSCode getConstructor() { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { if (!ScriptRuntime.hasTopCall(cx)) { return ScriptRuntime.doTopCall(this, cx, scope, thisObj, args, isStrict()); } var realThis = getThisObj(thisObj); - return descriptor.getCode().execute(cx, this, Undefined.instance, scope, realThis, args); + return descriptor.getCode().execute(cx, this, lexicalNewTarget, scope, realThis, args); } - public final Scriptable getThisObj(Scriptable thisObj) { + public final Object getThisObj(Object thisObj) { if (descriptor.hasLexicalThis()) { return lexicalThis; - } else if (!descriptor.isStrict() && (thisObj == null || Undefined.isUndefined(thisObj))) { - var res = ScriptableObject.getTopLevelScope(getDeclarationScope()).getGlobalThis(); - return res; + } else if (!descriptor.isStrict()) { + if (thisObj == null || Undefined.isUndefined(thisObj)) { + return ScriptableObject.getTopLevelScope(getDeclarationScope()).getGlobalThis(); + } else { + return ScriptRuntime.toObject(getDeclarationScope(), thisObj); + } } else { return thisObj; } } @Override - public Scriptable construct(Context cx, VarScope scope, Object[] args) { + public Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { if (!ScriptRuntime.hasTopCall(cx)) { return (Scriptable) ScriptRuntime.doTopCall( (lcx, lscope, lthisObj, largs) -> construct(lcx, lscope, largs), cx, - scope, + s, null, args, isStrict()); @@ -170,14 +186,22 @@ public Scriptable construct(Context cx, VarScope scope, Object[] args) { if (descriptor.getConstructor() == null) { throw ScriptRuntime.typeErrorById("msg.not.ctor", getFunctionName()); } - var thisObj = homeObject == null ? createObject(cx, scope) : null; + if (nt == null || Undefined.isUndefined(nt)) { + nt = this; + } + thisObj = homeObject == null ? this.createObject(cx, s, nt) : null; // Pass `this` in as new.target for now. This can change when // the public `construct` signature changes. - var res = descriptor.getConstructor().execute(cx, this, this, scope, thisObj, args); + var res = descriptor.getConstructor().execute(cx, this, nt, s, thisObj, args); if (res instanceof Scriptable) { thisObj = (Scriptable) res; } - return thisObj; + return (Scriptable) thisObj; + } + + @Override + public Scriptable construct(Context cx, VarScope scope, Object[] args) { + return construct(cx, this, scope, null, args); } public boolean isScript() { @@ -208,12 +232,16 @@ public Scriptable getHomeObject() { return homeObject; } + public Object getLexicalNewTarget() { + return lexicalNewTarget; + } + @Override public void setHomeObject(Scriptable homeObject) { throw new UnsupportedOperationException("Cannot set home object on JS function."); } - public Scriptable getFunctionThis(Scriptable functionThis) { + public Object getFunctionThis(Scriptable functionThis) { if (descriptor.hasLexicalThis()) { return this.lexicalThis; } else { @@ -237,7 +265,7 @@ public static JSFunction createFunction( Scriptable homeObject, Object staticSecurityDomain) { assert (desc.getSecurityDomain() == staticSecurityDomain); - JSFunction f = new JSFunction(cx, scope, desc, null, homeObject); + JSFunction f = new JSFunction(cx, scope, desc, null, Undefined.instance, homeObject); return f; } @@ -245,7 +273,7 @@ public static JSFunction createFunction( static JSFunction createFunction( Context cx, VarScope scope, JSDescriptor parent, int index, Scriptable homeObject) { JSDescriptor desc = parent.getFunction(index); - JSFunction f = new JSFunction(cx, scope, desc, null, homeObject); + JSFunction f = new JSFunction(cx, scope, desc, null, Undefined.instance, homeObject); return f; } diff --git a/rhino/src/main/java/org/mozilla/javascript/JSScript.java b/rhino/src/main/java/org/mozilla/javascript/JSScript.java index 187c39c181e..665232e869f 100644 --- a/rhino/src/main/java/org/mozilla/javascript/JSScript.java +++ b/rhino/src/main/java/org/mozilla/javascript/JSScript.java @@ -29,7 +29,7 @@ JSCode getCode() { } @Override - public Object exec(Context cx, VarScope scope, Scriptable thisObj) { + public Object exec(Context cx, VarScope scope, Object thisObj) { Object ret; if (!ScriptRuntime.hasTopCall(cx)) { // It will go through "call" path. but they are equivalent diff --git a/rhino/src/main/java/org/mozilla/javascript/JavaMembers.java b/rhino/src/main/java/org/mozilla/javascript/JavaMembers.java index c8574d094fd..1f6f16bdb7d 100644 --- a/rhino/src/main/java/org/mozilla/javascript/JavaMembers.java +++ b/rhino/src/main/java/org/mozilla/javascript/JavaMembers.java @@ -109,7 +109,7 @@ Object get(Scriptable obj, VarScope scope, String name, Object javaObject, boole return new FieldAndMethods(scope, withField); } else { var method = (ExecutableOverload) member; - var built = new NativeJavaMethod(method.methods, method.name); + var built = new NativeJavaMethod(scope, method.methods, method.name); ScriptRuntime.setFunctionProtoAndParent( built, Context.getCurrentContext(), scope, false); return built; @@ -290,7 +290,7 @@ private Object getExplicitFunction( Scriptable prototype = ScriptableObject.getFunctionPrototype(scope); if (methodOrCtor.isConstructor()) { - NativeJavaConstructor fun = new NativeJavaConstructor(methodOrCtor); + NativeJavaConstructor fun = new NativeJavaConstructor(scope, methodOrCtor); fun.setPrototype(prototype); member = fun; ht.put(name, fun); @@ -300,7 +300,7 @@ private Object getExplicitFunction( if (member instanceof ExecutableOverload && ((ExecutableOverload) member).methods.length > 1) { - NativeJavaMethod fun = new NativeJavaMethod(methodOrCtor, name); + NativeJavaMethod fun = new NativeJavaMethod(scope, methodOrCtor, name); fun.setPrototype(prototype); ht.put(name, fun); member = fun; @@ -458,7 +458,7 @@ private void reflect( collectFields(accessibleFields, isStatic, typeFactory); var table = isStatic ? staticMembers : members; - table.putAll(extractBeaning(table, isStatic, includePrivate)); + table.putAll(extractBeaning(scope, table, isStatic, includePrivate)); } // Reflect constructors @@ -467,7 +467,7 @@ private void reflect( for (int i = 0; i != constructors.length; ++i) { ctorMembers[i] = new ExecutableBox(constructors[i], typeFactory); } - ctors = new NativeJavaMethod(ctorMembers, cl.getSimpleName()); + ctors = new NativeJavaMethod(scope, ctorMembers, cl.getSimpleName()); } /** @@ -592,7 +592,7 @@ private static String getBeanName(String nameComponent) { * member table at this stage */ private static Map extractBeaning( - Map members, boolean isStatic, boolean includePrivate) { + VarScope scope, Map members, boolean isStatic, boolean includePrivate) { var beans = new HashMap(); for (var entry : members.entrySet()) { var name = entry.getKey(); @@ -624,16 +624,16 @@ private static Map extractBeaning( // prefer 'get' over 'is' || bean.getter.getFunctionName().startsWith("is")) { if (method.methods.length == 1) { - bean.getter = new NativeJavaMethod(method.methods, name); + bean.getter = new NativeJavaMethod(scope, method.methods, name); } else { - bean.getter = new NativeJavaMethod(candidate, name); + bean.getter = new NativeJavaMethod(scope, candidate, name); } } } } else { // isSetBeaning var bean = beans.computeIfAbsent(beanName, BeanProperty::new); // capture all possible setters for now, actual setter will be searched later - bean.setter = new NativeJavaMethod(method.methods, name); + bean.setter = new NativeJavaMethod(scope, method.methods, name); } } @@ -651,7 +651,7 @@ private static Map extractBeaning( // We have a getter. Now, do we have a setter with matching type? match = extractSetMethod(type, setterCandidates.methods, isStatic); if (match != null) { - bean.setter = new NativeJavaMethod(match, match.getName()); + bean.setter = new NativeJavaMethod(scope, match, match.getName()); continue; } } @@ -911,7 +911,7 @@ class FieldAndMethods extends NativeJavaMethod { private static final long serialVersionUID = -9222428244284796755L; FieldAndMethods(VarScope scope, ExecutableOverload.WithField withField) { - super(withField.methods, withField.name); + super(scope, withField.methods, withField.name); this.field = withField.field; setParentScope(scope); setPrototype(ScriptableObject.getFunctionPrototype(scope)); diff --git a/rhino/src/main/java/org/mozilla/javascript/KnownBuiltInFunction.java b/rhino/src/main/java/org/mozilla/javascript/KnownBuiltInFunction.java index 56a3d5cda89..85bb7adfd34 100644 --- a/rhino/src/main/java/org/mozilla/javascript/KnownBuiltInFunction.java +++ b/rhino/src/main/java/org/mozilla/javascript/KnownBuiltInFunction.java @@ -12,7 +12,7 @@ */ public class KnownBuiltInFunction extends LambdaFunction { - private static final long serialVersionUID = -8388132362854748293L; + private static final long serialVersionUID = 4527445659952834584L; private final Object tag; diff --git a/rhino/src/main/java/org/mozilla/javascript/LambdaConstructor.java b/rhino/src/main/java/org/mozilla/javascript/LambdaConstructor.java index 8d7d4ac56a4..ed3ef900807 100644 --- a/rhino/src/main/java/org/mozilla/javascript/LambdaConstructor.java +++ b/rhino/src/main/java/org/mozilla/javascript/LambdaConstructor.java @@ -124,7 +124,7 @@ protected Constructable getTargetConstructor() { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { if ((flags & CONSTRUCTOR_FUNCTION) == 0) { throw ScriptRuntime.typeErrorById("msg.constructor.no.function", getFunctionName()); } diff --git a/rhino/src/main/java/org/mozilla/javascript/LambdaFunction.java b/rhino/src/main/java/org/mozilla/javascript/LambdaFunction.java index f6ae5f1e80e..7f24d1a56e7 100644 --- a/rhino/src/main/java/org/mozilla/javascript/LambdaFunction.java +++ b/rhino/src/main/java/org/mozilla/javascript/LambdaFunction.java @@ -13,7 +13,7 @@ */ public class LambdaFunction extends BaseFunction { - private static final long serialVersionUID = -8388132362854748293L; + private static final long serialVersionUID = 6594410813947157220L; // The target is expected to be a lambda. Lambdas may be serialized, which // requires this special interface. @@ -38,6 +38,7 @@ public LambdaFunction( int length, SerializableCallable target, boolean defaultPrototype) { + super(scope); this.target = target; this.name = name; this.length = length; @@ -78,6 +79,7 @@ public LambdaFunction( int length, Object prototype, SerializableCallable target) { + super(scope); this.target = target; this.name = name; this.length = length; @@ -87,6 +89,7 @@ public LambdaFunction( /** Create a new built-in function, with no name, and no default prototype. */ public LambdaFunction(VarScope scope, int length, SerializableCallable target) { + super(scope); this.target = target; this.length = length; this.name = ""; @@ -94,7 +97,7 @@ public LambdaFunction(VarScope scope, int length, SerializableCallable target) { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { return target.call(cx, getDeclarationScope(), thisObj, args); } diff --git a/rhino/src/main/java/org/mozilla/javascript/LazilyLoadedCtor.java b/rhino/src/main/java/org/mozilla/javascript/LazilyLoadedCtor.java index a08e568fc43..d7820a68138 100644 --- a/rhino/src/main/java/org/mozilla/javascript/LazilyLoadedCtor.java +++ b/rhino/src/main/java/org/mozilla/javascript/LazilyLoadedCtor.java @@ -17,7 +17,7 @@ *

This improves startup time and average memory usage. */ public final class LazilyLoadedCtor> implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -1531091529063000542L; private static final int STATE_BEFORE_INIT = 0; private static final int STATE_INITIALIZING = 1; private static final int STATE_WITH_VALUE = 2; diff --git a/rhino/src/main/java/org/mozilla/javascript/LocalScope.java b/rhino/src/main/java/org/mozilla/javascript/LocalScope.java new file mode 100644 index 00000000000..6579204da3d --- /dev/null +++ b/rhino/src/main/java/org/mozilla/javascript/LocalScope.java @@ -0,0 +1,18 @@ +package org.mozilla.javascript; + +public class LocalScope extends DeclarationScope { + private static final long serialVersionUID = -7471457301304454454L; + + public LocalScope(VarScope parentScope) { + super(parentScope); + } + + public boolean isNestedScope() { + return true; + } + + @Override + public void putConst(String name, VarScope start, Object value) { + super.put(name, start, value); + } +} diff --git a/rhino/src/main/java/org/mozilla/javascript/MemberBox.java b/rhino/src/main/java/org/mozilla/javascript/MemberBox.java index 1772a2d1b08..8445fd3f61a 100644 --- a/rhino/src/main/java/org/mozilla/javascript/MemberBox.java +++ b/rhino/src/main/java/org/mozilla/javascript/MemberBox.java @@ -171,7 +171,7 @@ Function asGetterFunction(final String name) { public Object call( Context cx, VarScope callScope, - Scriptable thisObj, + Object thisObj, Object[] originalArgs) { MemberBox nativeGetter = MemberBox.this; if (nativeGetter.delegateTo == null) { @@ -204,7 +204,7 @@ Function asSetterFunction(final String name) { public Object call( Context cx, VarScope callScope, - Scriptable thisObj, + Object thisObj, Object[] originalArgs) { MemberBox nativeSetter = MemberBox.this; Object value = diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeArray.java b/rhino/src/main/java/org/mozilla/javascript/NativeArray.java index 1601f788d2f..f245bd8c8e0 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeArray.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeArray.java @@ -645,7 +645,7 @@ private static Object js_from( final Scriptable items = ScriptRuntime.toObject(s, (args.length >= 1) ? args[0] : Undefined.instance); Object mapArg = (args.length >= 2) ? args[1] : Undefined.instance; - Scriptable thisArg = null; + Object thisArg = null; final boolean mapping = !Undefined.isUndefined(mapArg); Function mapFn = null; diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeArrayIterator.java b/rhino/src/main/java/org/mozilla/javascript/NativeArrayIterator.java index 5593f0fad1c..4f05fe8b4ed 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeArrayIterator.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeArrayIterator.java @@ -15,13 +15,17 @@ public enum ARRAY_ITERATOR_TYPE { VALUES } - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 3370645355934941865L; private static final String ITERATOR_TAG = "ArrayIterator"; + private static final ClassDescriptor DESCRIPTOR = + ES6Iterator.makeDescriptor(ITERATOR_TAG, "Array Iterator"); + private ARRAY_ITERATOR_TYPE type; - static void init(TopLevel scope, boolean sealed) { - ES6Iterator.init(scope, sealed, new NativeArrayIterator(), ITERATOR_TAG); + static void init(Context cx, VarScope scope, boolean sealed) { + ES6Iterator.initialize( + DESCRIPTOR, cx, (TopLevel) scope, new NativeArrayIterator(), sealed, ITERATOR_TAG); } /** Only for constructing the prototype object. */ diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeBigInt.java b/rhino/src/main/java/org/mozilla/javascript/NativeBigInt.java index f3322f6b233..56f5ae2dd56 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeBigInt.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeBigInt.java @@ -6,6 +6,10 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + import java.math.BigInteger; /** This class implements the BigInt native object. */ @@ -14,46 +18,33 @@ final class NativeBigInt extends ScriptableObject { private static final String CLASS_NAME = "BigInt"; + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 1, + NativeBigInt::js_constructorFunc, + NativeBigInt::js_constructor) + .withMethod(CTOR, "asIntN", 2, NativeBigInt::js_asIntN) + .withMethod(CTOR, "asUintN", 2, NativeBigInt::js_asUintN) + .withMethod(PROTO, "toString", 0, NativeBigInt::js_toString) + // Alias toLocaleString to toString + .withMethod(PROTO, "toLocaleString", 0, NativeBigInt::js_toString) + .withMethod(PROTO, "toSource", 0, NativeBigInt::js_toSource) + .withMethod(PROTO, "valueOf", 0, NativeBigInt::js_valueOf) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value(CLASS_NAME, DONTENUM | READONLY)) + .build(); + } + private final BigInteger bigIntValue; static Object init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - CLASS_NAME, - 1, - NativeBigInt::js_constructorFunc, - NativeBigInt::js_constructor); - constructor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - constructor.defineConstructorMethod( - scope, - "asIntN", - 2, - (Context lcx, VarScope lscope, Scriptable thisObj, Object[] args) -> - js_asIntOrUintN(true, args)); - constructor.defineConstructorMethod( - scope, - "asUintN", - 2, - (Context lcx, VarScope lscope, Scriptable thisObj, Object[] args) -> - js_asIntOrUintN(false, args)); - constructor.definePrototypeMethod(scope, "toString", 0, NativeBigInt::js_toString); - // Alias toLocaleString to toString - constructor.definePrototypeMethod(scope, "toLocaleString", 0, NativeBigInt::js_toString); - constructor.definePrototypeMethod(scope, "toSource", 0, NativeBigInt::js_toSource); - constructor.definePrototypeMethod( - scope, - "valueOf", - 0, - (Context lcx, VarScope lscope, Scriptable thisObj, Object[] args) -> - toSelf(thisObj).bigIntValue); - constructor.definePrototypeProperty( - SymbolKey.TO_STRING_TAG, CLASS_NAME, DONTENUM | READONLY); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } - return constructor; + return DESCRIPTOR.buildConstructor(cx, scope, new NativeObject(), sealed); } NativeBigInt(BigInteger bigInt) { @@ -70,15 +61,17 @@ private static NativeBigInt toSelf(Object thisObj) { } private static Object js_constructorFunc( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return (args.length >= 1) ? ScriptRuntime.toBigInt(args[0]) : BigInteger.ZERO; } - private static Scriptable js_constructor(Context cx, VarScope scope, Object[] args) { + private static Scriptable js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { throw ScriptRuntime.typeErrorById("msg.no.new", CLASS_NAME); } - private static Object js_toString(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toString( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { int base = (args.length == 0 || args[0] == Undefined.instance) ? 10 @@ -87,10 +80,26 @@ private static Object js_toString(Context cx, VarScope scope, Object thisObj, Ob return ScriptRuntime.bigIntToString(value, base); } - private static Object js_toSource(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toSource( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return "(new BigInt(" + ScriptRuntime.toString(toSelf(thisObj).bigIntValue) + "))"; } + private static Object js_asIntN( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return js_asIntOrUintN(true, args); + } + + private static Object js_asUintN( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return js_asIntOrUintN(false, args); + } + + private static Object js_valueOf( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return toSelf(thisObj).bigIntValue; + } + private static Object js_asIntOrUintN(boolean isSigned, Object[] args) { int bits = ScriptRuntime.toIndex(args.length < 1 ? Undefined.instance : args[0]); BigInteger bigInt = ScriptRuntime.toBigInt(args.length < 2 ? Undefined.instance : args[1]); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeBoolean.java b/rhino/src/main/java/org/mozilla/javascript/NativeBoolean.java index 26557459749..7658259ac47 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeBoolean.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeBoolean.java @@ -71,8 +71,7 @@ private static NativeBoolean js_constructor( Context cx, JSFunction fun, Object nt, VarScope s, Object thisObj, Object[] args) { boolean b = ScriptRuntime.toBoolean(args.length > 0 ? args[0] : Undefined.instance); var res = new NativeBoolean(b); - res.setPrototype((Scriptable) fun.getPrototypeProperty()); - res.setParentScope(s); + ScriptRuntime.setBuiltinProtoAndParent(res, fun, nt, s, TopLevel.Builtins.Boolean); return res; } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeCallSite.java b/rhino/src/main/java/org/mozilla/javascript/NativeCallSite.java index a1fe0ef57b6..e0d34e5eba1 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeCallSite.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeCallSite.java @@ -6,26 +6,45 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + /** * This class is used by the V8 extension "Error.prepareStackTrace." It is passed to that function, * which may then use it to format the stack as it sees fit. */ -public class NativeCallSite extends IdScriptableObject { +public class NativeCallSite extends ScriptableObject { private static final long serialVersionUID = 2688372752566593594L; - private static final String CALLSITE_TAG = "CallSite"; + private ScriptStackElement element; - static void init(VarScope scope, boolean sealed) { - NativeCallSite cs = new NativeCallSite(); - cs.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + "CallSite", + 0, + NativeCallSite::js_constructor, + NativeCallSite::js_constructor) + .withMethod(PROTO, "getThis", 0, NativeCallSite::js_getThis) + .withMethod(PROTO, "getTypeName", 0, NativeCallSite::js_getTypeName) + .withMethod(PROTO, "getFunction", 0, NativeCallSite::js_getFunction) + .withMethod(PROTO, "getFunctionName", 0, NativeCallSite::js_getFunctionName) + .withMethod(PROTO, "getMethodName", 0, NativeCallSite::js_getMethodName) + .withMethod(PROTO, "getFileName", 0, NativeCallSite::js_getFileName) + .withMethod(PROTO, "getLineNumber", 0, NativeCallSite::js_getLineNumber) + .withMethod(PROTO, "getColumnNumber", 0, NativeCallSite::js_getColumnNumber) + .withMethod(PROTO, "getEvalOrigin", 0, NativeCallSite::js_getEvalOrigin) + .withMethod(PROTO, "isToplevel", 0, NativeCallSite::js_isToplevel) + .withMethod(PROTO, "isEval", 0, NativeCallSite::js_isEval) + .withMethod(PROTO, "isNative", 0, NativeCallSite::js_isNative) + .withMethod(PROTO, "isConstructor", 0, NativeCallSite::js_isConstructor) + .withMethod(PROTO, "toString", 0, NativeCallSite::js_toString) + .build(); } - static NativeCallSite make(VarScope scope, Scriptable ctorObj) { - NativeCallSite cs = new NativeCallSite(); - Scriptable proto = (Scriptable) ctorObj.get("prototype", ctorObj); - cs.setParentScope(scope); - cs.setPrototype(proto); - return cs; + static void init(Context cx, VarScope scope, boolean sealed) { + DESCRIPTOR.buildConstructor(cx, scope, new NativeCallSite(), sealed); } private NativeCallSite() {} @@ -39,113 +58,6 @@ public String getClassName() { return "CallSite"; } - @Override - protected void initPrototypeId(int id) { - String s; - int arity; - switch (id) { - case Id_constructor: - arity = 0; - s = "constructor"; - break; - case Id_getThis: - arity = 0; - s = "getThis"; - break; - case Id_getTypeName: - arity = 0; - s = "getTypeName"; - break; - case Id_getFunction: - arity = 0; - s = "getFunction"; - break; - case Id_getFunctionName: - arity = 0; - s = "getFunctionName"; - break; - case Id_getMethodName: - arity = 0; - s = "getMethodName"; - break; - case Id_getFileName: - arity = 0; - s = "getFileName"; - break; - case Id_getLineNumber: - arity = 0; - s = "getLineNumber"; - break; - case Id_getColumnNumber: - arity = 0; - s = "getColumnNumber"; - break; - case Id_getEvalOrigin: - arity = 0; - s = "getEvalOrigin"; - break; - case Id_isToplevel: - arity = 0; - s = "isToplevel"; - break; - case Id_isEval: - arity = 0; - s = "isEval"; - break; - case Id_isNative: - arity = 0; - s = "isNative"; - break; - case Id_isConstructor: - arity = 0; - s = "isConstructor"; - break; - case Id_toString: - arity = 0; - s = "toString"; - break; - default: - throw new IllegalArgumentException(String.valueOf(id)); - } - initPrototypeMethod(CALLSITE_TAG, id, s, arity); - } - - @Override - public Object execIdCall( - IdFunctionObject f, Context cx, VarScope scope, Scriptable thisObj, Object[] args) { - if (!f.hasTag(CALLSITE_TAG)) { - return super.execIdCall(f, cx, scope, thisObj, args); - } - int id = f.methodId(); - switch (id) { - case Id_constructor: - return make(scope, f); - case Id_getFunctionName: - return getFunctionName(thisObj); - case Id_getFileName: - return getFileName(thisObj); - case Id_getLineNumber: - return getLineNumber(thisObj); - case Id_getThis: - case Id_getTypeName: - case Id_getFunction: - case Id_getColumnNumber: - return Undefined.instance; - case Id_getMethodName: - return null; - case Id_getEvalOrigin: - case Id_isEval: - case Id_isConstructor: - case Id_isNative: - case Id_isToplevel: - return Boolean.FALSE; - case Id_toString: - return js_toString(thisObj); - default: - throw new IllegalArgumentException(String.valueOf(id)); - } - } - @Override public String toString() { if (element == null) { @@ -154,6 +66,84 @@ public String toString() { return element.toString(); } + private static Object js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var res = new NativeCallSite(); + res.setPrototype((Scriptable) f.getPrototypeProperty()); + res.setParentScope(s); + return res; + } + + private static Object js_getThis( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Undefined.instance; + } + + private static Object js_getTypeName( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Undefined.instance; + } + + private static Object js_getFunction( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Undefined.instance; + } + + private static Object js_getFunctionName( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return getFunctionName((Scriptable) thisObj); + } + + private static Object js_getMethodName( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return null; + } + + private static Object js_getFileName( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return getFileName((Scriptable) thisObj); + } + + private static Object js_getLineNumber( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return getLineNumber((Scriptable) thisObj); + } + + private static Object js_getColumnNumber( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Undefined.instance; + } + + private static Object js_getEvalOrigin( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Boolean.FALSE; + } + + private static Object js_isToplevel( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Boolean.FALSE; + } + + private static Object js_isEval( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Boolean.FALSE; + } + + private static Object js_isNative( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Boolean.FALSE; + } + + private static Object js_isConstructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return Boolean.FALSE; + } + + private static Object js_toString( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return js_toString((Scriptable) thisObj); + } + private static Object js_toString(Scriptable obj) { while (obj != null && !(obj instanceof NativeCallSite)) { obj = obj.getPrototype(); @@ -202,77 +192,4 @@ private static Object getLineNumber(Scriptable obj) { } return Integer.valueOf(cs.element.lineNumber); } - - @Override - protected int findPrototypeId(String s) { - int id; - switch (s) { - case "constructor": - id = Id_constructor; - break; - case "getThis": - id = Id_getThis; - break; - case "getTypeName": - id = Id_getTypeName; - break; - case "getFunction": - id = Id_getFunction; - break; - case "getFunctionName": - id = Id_getFunctionName; - break; - case "getMethodName": - id = Id_getMethodName; - break; - case "getFileName": - id = Id_getFileName; - break; - case "getLineNumber": - id = Id_getLineNumber; - break; - case "getColumnNumber": - id = Id_getColumnNumber; - break; - case "getEvalOrigin": - id = Id_getEvalOrigin; - break; - case "isToplevel": - id = Id_isToplevel; - break; - case "isEval": - id = Id_isEval; - break; - case "isNative": - id = Id_isNative; - break; - case "isConstructor": - id = Id_isConstructor; - break; - case "toString": - id = Id_toString; - break; - default: - id = 0; - break; - } - return id; - } - - private static final int Id_constructor = 1, - Id_getThis = 2, - Id_getTypeName = 3, - Id_getFunction = 4, - Id_getFunctionName = 5, - Id_getMethodName = 6, - Id_getFileName = 7, - Id_getLineNumber = 8, - Id_getColumnNumber = 9, - Id_getEvalOrigin = 10, - Id_isToplevel = 11, - Id_isEval = 12, - Id_isNative = 13, - Id_isConstructor = 14, - Id_toString = 15, - MAX_PROTOTYPE_ID = 15; } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeCollectionIterator.java b/rhino/src/main/java/org/mozilla/javascript/NativeCollectionIterator.java index c84174b4167..82f78a168bc 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeCollectionIterator.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeCollectionIterator.java @@ -18,10 +18,6 @@ enum Type { BOTH } - static void init(TopLevel scope, String tag, boolean sealed) { - ES6Iterator.init(scope, sealed, new NativeCollectionIterator(tag), tag); - } - public NativeCollectionIterator(String tag) { this.className = tag; this.iterator = Collections.emptyIterator(); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeConsole.java b/rhino/src/main/java/org/mozilla/javascript/NativeConsole.java index 6ac688d0c09..b1b8d86175a 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeConsole.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeConsole.java @@ -255,7 +255,7 @@ private static String formatObj(Context cx, VarScope scope, Object arg) { public Object call( Context callCx, VarScope callScope, - Scriptable callThisObj, + Object callThisObj, Object[] callArgs) { Object value = callArgs[1]; while (value instanceof Delegator) { diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeContinuation.java b/rhino/src/main/java/org/mozilla/javascript/NativeContinuation.java index b7dc353a464..61ab6da3a83 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeContinuation.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeContinuation.java @@ -8,16 +8,34 @@ import java.util.Objects; -public final class NativeContinuation extends IdScriptableObject implements Function { +public final class NativeContinuation extends ScriptableObject implements Function { private static final long serialVersionUID = 1794167133757605367L; - private static final Object FTAG = "Continuation"; + private static final String CLASS_NAME = "Continuation"; + + private static final ClassDescriptor DESCRIPTOR; + private static final JSDescriptor CTOR_DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 0, + NativeContinuation::js_constructor, + NativeContinuation::js_constructor) + .build(); + CTOR_DESCRIPTOR = DESCRIPTOR.ctorDesc(); + } private Object implementation; public static void init(Context cx, VarScope scope, boolean sealed) { - NativeContinuation obj = new NativeContinuation(); - obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + DESCRIPTOR.buildConstructor(cx, scope, new NativeContinuation(), sealed); + } + + private static Object js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + throw Context.reportRuntimeError("Direct call is not supported"); } public Object getImplementation() { @@ -39,15 +57,17 @@ public Scriptable construct(Context cx, VarScope scope, Object[] args) { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { + throw Context.reportRuntimeError("Direct call is not supported"); + } + + @Override + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { return Interpreter.restartContinuation(this, cx, scope, args); } - public static boolean isContinuationConstructor(IdFunctionObject f) { - if (f.hasTag(FTAG) && f.methodId() == Id_constructor) { - return true; - } - return false; + public static boolean isContinuationConstructor(JSFunction f) { + return f.getDescriptor() == CTOR_DESCRIPTOR; } /** @@ -61,49 +81,4 @@ public static boolean isContinuationConstructor(IdFunctionObject f) { public static boolean equalImplementations(NativeContinuation c1, NativeContinuation c2) { return Objects.equals(c1.implementation, c2.implementation); } - - @Override - protected void initPrototypeId(int id) { - String s; - int arity; - switch (id) { - case Id_constructor: - arity = 0; - s = "constructor"; - break; - default: - throw new IllegalArgumentException(String.valueOf(id)); - } - initPrototypeMethod(FTAG, id, s, arity); - } - - @Override - public Object execIdCall( - IdFunctionObject f, Context cx, VarScope scope, Scriptable thisObj, Object[] args) { - if (!f.hasTag(FTAG)) { - return super.execIdCall(f, cx, scope, thisObj, args); - } - int id = f.methodId(); - switch (id) { - case Id_constructor: - throw Context.reportRuntimeError("Direct call is not supported"); - } - throw new IllegalArgumentException(String.valueOf(id)); - } - - @Override - protected int findPrototypeId(String s) { - int id; - switch (s) { - case "constructor": - id = Id_constructor; - break; - default: - id = 0; - break; - } - return id; - } - - private static final int Id_constructor = 1, MAX_PROTOTYPE_ID = 1; } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeError.java b/rhino/src/main/java/org/mozilla/javascript/NativeError.java index 27ffa0f036d..4cdc61ae223 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeError.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeError.java @@ -82,7 +82,7 @@ private static Object js_isError( static void init(Context cx, VarScope scope, boolean sealed) { var ctor = DESCRIPTOR.buildConstructor(cx, scope, new NativeObject(), sealed); - NativeCallSite.init(scope, sealed); + NativeCallSite.init(cx, scope, sealed); ProtoProps protoProps = new ProtoProps(); ((ScriptableObject) ctor.getPrototypeProperty()).associateValue(ProtoProps.KEY, protoProps); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeFunction.java b/rhino/src/main/java/org/mozilla/javascript/NativeFunction.java index 2652854d81a..fd54e548d17 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeFunction.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeFunction.java @@ -20,6 +20,10 @@ public abstract class NativeFunction extends BaseFunction { private boolean isShorthand; + protected NativeFunction(VarScope scope) { + super(scope); + } + public final void initScriptFunction( Context cx, VarScope scope, boolean es6GeneratorFunction, boolean isShorthand) { ScriptRuntime.setFunctionProtoAndParent(this, cx, scope, es6GeneratorFunction); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeGenerator.java b/rhino/src/main/java/org/mozilla/javascript/NativeGenerator.java index fb89f2d7031..7e3b47565ab 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeGenerator.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeGenerator.java @@ -6,40 +6,36 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.Symbol.Kind.REGULAR; + /** * This class implements generator objects. See Generators * * @author Norris Boyd */ -public final class NativeGenerator extends IdScriptableObject { - private static final long serialVersionUID = 1645892441041347273L; - - private static final Object GENERATOR_TAG = "Generator"; - - static NativeGenerator init(TopLevel scope, boolean sealed) { - // Generator - // Can't use "NativeGenerator().exportAsJSClass" since we don't want - // to define "Generator" as a constructor in the top-level scope. - - NativeGenerator prototype = new NativeGenerator(); - if (scope != null) { - prototype.setParentScope(scope); - prototype.setPrototype(getObjectPrototype(scope)); - } - prototype.activatePrototypeMap(MAX_PROTOTYPE_ID); - if (sealed) { - prototype.sealObject(); - } - - // Need to access Generator prototype when constructing - // Generator instances, but don't have a generator constructor - // to use to find the prototype. Use the "associateValue" - // approach instead. - if (scope != null) { - scope.associateValue(GENERATOR_TAG, prototype); - } +public final class NativeGenerator extends ScriptableObject { + private static final long serialVersionUID = -1383456283657974338L; + + private static final SymbolKey GENERATOR_TAG = new SymbolKey("GeneratorPrototype", REGULAR); + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder(GENERATOR_TAG) + .withMethod(CTOR, "close", 1, NativeGenerator::js_close) + .withMethod(CTOR, "next", 1, NativeGenerator::js_next) + .withMethod(CTOR, "send", 0, NativeGenerator::js_send) + .withMethod(CTOR, "throw", 0, NativeGenerator::js_throw) + .withMethod(CTOR, "__iterator__", 1, NativeGenerator::js_iterator) + .build(); + } + static NativeGenerator init(Context cx, TopLevel scope, boolean sealed) { + var prototype = new NativeGenerator(); + DESCRIPTOR.populateGlobal(cx, scope, prototype, sealed); + scope.associateValue(GENERATOR_TAG, prototype); return prototype; } @@ -66,78 +62,49 @@ public String getClassName() { return "Generator"; } - @Override - protected void initPrototypeId(int id) { - String s; - int arity; - switch (id) { - case Id_close: - arity = 1; - s = "close"; - break; - case Id_next: - arity = 1; - s = "next"; - break; - case Id_send: - arity = 0; - s = "send"; - break; - case Id_throw: - arity = 0; - s = "throw"; - break; - case Id___iterator__: - arity = 1; - s = "__iterator__"; - break; - default: - throw new IllegalArgumentException(String.valueOf(id)); - } - initPrototypeMethod(GENERATOR_TAG, id, s, arity); + private static Object js_close( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + // need to run any pending finally clauses + var generator = realThis(thisObj); + return generator.resume(cx, s, GENERATOR_CLOSE, new GeneratorClosedException()); } - @Override - public Object execIdCall( - IdFunctionObject f, Context cx, VarScope scope, Scriptable thisObj, Object[] args) { - if (!f.hasTag(GENERATOR_TAG)) { - return super.execIdCall(f, cx, scope, thisObj, args); - } - int id = f.methodId(); - - NativeGenerator generator = ensureType(thisObj, NativeGenerator.class, f); - - switch (id) { - case Id_close: - // need to run any pending finally clauses - return generator.resume(cx, scope, GENERATOR_CLOSE, new GeneratorClosedException()); - - case Id_next: - // arguments to next() are ignored - generator.firstTime = false; - return generator.resume(cx, scope, GENERATOR_SEND, Undefined.instance); - - case Id_send: - { - Object arg = args.length > 0 ? args[0] : Undefined.instance; - if (generator.firstTime && !arg.equals(Undefined.instance)) { - throw ScriptRuntime.typeErrorById("msg.send.newborn"); - } - return generator.resume(cx, scope, GENERATOR_SEND, arg); - } - - case Id_throw: - return generator.resume( - cx, scope, GENERATOR_THROW, args.length > 0 ? args[0] : Undefined.instance); - - case Id___iterator__: - return thisObj; - - default: - throw new IllegalArgumentException(String.valueOf(id)); + private static Object js_next( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + // arguments to next() are ignored + var generator = realThis(thisObj); + generator.firstTime = false; + return generator.resume(cx, s, GENERATOR_SEND, Undefined.instance); + } + + private static Object js_send( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + { + var generator = realThis(thisObj); + Object arg = args.length > 0 ? args[0] : Undefined.instance; + if (generator.firstTime && !arg.equals(Undefined.instance)) { + throw ScriptRuntime.typeErrorById("msg.send.newborn"); + } + return generator.resume(cx, s, GENERATOR_SEND, arg); } } + private static Object js_throw( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var generator = realThis(thisObj); + return generator.resume( + cx, s, GENERATOR_THROW, args.length > 0 ? args[0] : Undefined.instance); + } + + private static Object js_iterator( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return thisObj; + } + + private static NativeGenerator realThis(Object thisObj) { + return LambdaConstructor.convertThisObject(thisObj, NativeGenerator.class); + } + private Object resume(Context cx, VarScope scope, int operation, Object value) { if (savedState == null) { if (operation == GENERATOR_CLOSE) return Undefined.instance; @@ -176,39 +143,6 @@ private Object resume(Context cx, VarScope scope, int operation, Object value) { } } - @Override - protected int findPrototypeId(String s) { - int id; - switch (s) { - case "close": - id = Id_close; - break; - case "next": - id = Id_next; - break; - case "send": - id = Id_send; - break; - case "throw": - id = Id_throw; - break; - case "__iterator__": - id = Id___iterator__; - break; - default: - id = 0; - break; - } - return id; - } - - private static final int Id_close = 1, - Id_next = 2, - Id_send = 3, - Id_throw = 4, - Id___iterator__ = 5, - MAX_PROTOTYPE_ID = 5; - private JSFunction function; private Object savedState; private String lineSource; diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeGlobal.java b/rhino/src/main/java/org/mozilla/javascript/NativeGlobal.java index 92705b18b21..0438cb27460 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeGlobal.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeGlobal.java @@ -6,11 +6,14 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; import static org.mozilla.javascript.ScriptableObject.DONTENUM; -import static org.mozilla.javascript.ScriptableObject.PERMANENT; -import static org.mozilla.javascript.ScriptableObject.READONLY; import java.io.Serializable; +import java.util.EnumMap; +import java.util.Map; import org.mozilla.javascript.xml.XMLLib; /** @@ -23,37 +26,73 @@ public class NativeGlobal implements Serializable { static final long serialVersionUID = 6080442165748707530L; + private static final ClassDescriptor DESCRIPTOR; + private static final JSDescriptor EVAL_DESCRIPTOR; + private static final Map ERROR_DESCRIPTORS; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder("globalThis") + .withMethod(CTOR, "decodeURI", 1, NativeGlobal::js_decodeURI) + .withMethod( + CTOR, "decodeURIComponent", 1, NativeGlobal::js_decodeURIComponent) + .withMethod(CTOR, "encodeURI", 1, NativeGlobal::js_encodeURI) + .withMethod( + CTOR, "encodeURIComponent", 1, NativeGlobal::js_encodeURIComponent) + .withMethod(CTOR, "escape", 1, NativeGlobal::js_escape) + .withMethod(CTOR, "isFinite", 1, NativeGlobal::js_isFinite) + .withMethod(CTOR, "isNaN", 1, NativeGlobal::js_isNaN) + .withMethod(CTOR, "isXMLName", 1, NativeGlobal::js_isXMLName) + .withMethod(CTOR, "parseFloat", 1, NativeGlobal::js_parseFloat) + .withMethod(CTOR, "parseInt", 2, NativeGlobal::js_parseInt) + .withMethod(CTOR, "unescape", 1, NativeGlobal::js_unescape) + .withMethod(CTOR, "uneval", 1, NativeGlobal::js_uneval) + .withMethod(CTOR, "eval", 1, NativeGlobal::js_eval) + .withProp(CTOR, "NaN", value(ScriptRuntime.NaNobj)) + .withProp(CTOR, "Infinity", value(Double.POSITIVE_INFINITY)) + .withProp(CTOR, "undefined", value(Undefined.instance)) + .build(); + EVAL_DESCRIPTOR = DESCRIPTOR.findCtorDesc("eval"); + + var errorDescs = + new EnumMap(TopLevel.NativeErrors.class); + for (var e : TopLevel.NativeErrors.values()) { + if (e == TopLevel.NativeErrors.Error) continue; + ClassDescriptor.Builder builder; + if (e != TopLevel.NativeErrors.AggregateError) { + builder = + new ClassDescriptor.Builder( + e.name(), + 1, + (c, f, nt, s, thisObj, args) -> NativeError.make(c, s, f, args), + (c, f, nt, s, thisObj, args) -> NativeError.make(c, s, f, args)); + } else { + builder = + new ClassDescriptor.Builder( + e.name(), + 2, + (c, f, nt, s, thisObj, args) -> + NativeError.makeAggregate(c, s, f, args), + (c, f, nt, s, thisObj, args) -> + NativeError.makeAggregate(c, s, f, args)); + } + errorDescs.put( + e, + builder.withProp(PROTO, "name", value(e.name(), DONTENUM)) + .withProp(PROTO, "message", value("", DONTENUM)) + .build()); + } + ERROR_DESCRIPTORS = Map.copyOf(errorDescs); + } + public static void init(Context cx, TopLevel scope, boolean sealed) { - defineGlobalFunction(scope, sealed, "decodeURI", 1, NativeGlobal::js_decodeURI); - defineGlobalFunction( - scope, sealed, "decodeURIComponent", 1, NativeGlobal::js_decodeURIComponent); - defineGlobalFunction(scope, sealed, "encodeURI", 1, NativeGlobal::js_encodeURI); - defineGlobalFunction( - scope, sealed, "encodeURIComponent", 1, NativeGlobal::js_encodeURIComponent); - defineGlobalFunction(scope, sealed, "escape", 1, NativeGlobal::js_escape); - defineGlobalFunction(scope, sealed, "isFinite", 1, NativeGlobal::js_isFinite); - defineGlobalFunction(scope, sealed, "isNaN", 1, NativeGlobal::js_isNaN); - defineGlobalFunction(scope, sealed, "isXMLName", 1, NativeGlobal::js_isXMLName); - defineGlobalFunction(scope, sealed, "parseFloat", 1, NativeGlobal::js_parseFloat); - defineGlobalFunction(scope, sealed, "parseInt", 2, NativeGlobal::js_parseInt); - defineGlobalFunction(scope, sealed, "unescape", 1, NativeGlobal::js_unescape); - defineGlobalFunction(scope, sealed, "uneval", 1, NativeGlobal::js_uneval); - defineGlobalFunctionEval(scope, sealed); - - ScriptableObject.defineProperty( - scope, "NaN", ScriptRuntime.NaNobj, READONLY | DONTENUM | PERMANENT); - ScriptableObject.defineProperty( - scope, "Infinity", Double.POSITIVE_INFINITY, READONLY | DONTENUM | PERMANENT); - ScriptableObject.defineProperty( - scope, "undefined", Undefined.instance, READONLY | DONTENUM | PERMANENT); var globalThis = scope.getGlobalThis(); + DESCRIPTOR.populateGlobal(cx, scope, globalThis, false); var obj = (Scriptable) scope.get("Object", scope); var objProto = (Scriptable) obj.get("prototype", obj); globalThis.setPrototype(objProto); - ScriptableObject.defineProperty(scope, "globalThis", globalThis, DONTENUM); - /* Each error constructor gets its own Error object as a prototype, with the 'name' property set to the name of the error. @@ -64,119 +103,43 @@ public static void init(Context cx, TopLevel scope, boolean sealed) { ScriptableObject.ensureScriptable( ScriptableObject.getProperty(nativeError, "prototype")); - for (TopLevel.NativeErrors error : TopLevel.NativeErrors.values()) { - if (error == TopLevel.NativeErrors.Error) { - // Error is initialized elsewhere and we should not overwrite it. - continue; - } - String name = error.name(); - TopLevel topLevelScope = ScriptableObject.getTopLevelScope(scope); - Function builtinErrorCtor = - TopLevel.getBuiltinCtor(cx, topLevelScope, TopLevel.Builtins.Error); - ScriptableObject errorProto = NativeError.makeProto(topLevelScope, builtinErrorCtor); - errorProto.defineProperty("name", name, DONTENUM); - errorProto.defineProperty("message", "", DONTENUM); - - BaseFunction ctor; - - // Building errors is complex because of the prototype chain requirements. This is a bit - // arcane, but it's a combination that makes test262 happy. - if (error == TopLevel.NativeErrors.AggregateError) { - var target = - new SerializableConstructable() { - // We need a reference to the LambdaFunction, so we use this "lateBound" - // trick. It ain't great, but it's the only idea I have. - private Function lateBoundCtor; - - @Override - public Scriptable construct( - Context callCx, VarScope callScope, Object[] args) { - return NativeError.makeAggregate( - callCx, callScope, lateBoundCtor, args); - } - }; - ctor = - new LambdaConstructor(scope, name, 2, target) { - // Necessary to make the test262 case - // built-ins/NativeErrors/AggregateError/newtarget-proto-custom.js work - // correctly - @Override - public Scriptable createObject(Context cx, VarScope scope) { - return null; - } - }; - target.lateBoundCtor = ctor; - } else { - var target = - new SerializableConstructable() { - private Function lateBoundCtor; - - @Override - public Scriptable construct( - Context callCx, VarScope callScope, Object[] args) { - return NativeError.make(callCx, callScope, lateBoundCtor, args); - } - }; - ctor = new LambdaConstructor(scope, name, 1, target); - target.lateBoundCtor = ctor; - } - - ctor.setImmunePrototypeProperty(errorProto); - ctor.setPrototype(nativeError); - errorProto.put("constructor", errorProto, ctor); - errorProto.setAttributes("constructor", ScriptableObject.DONTENUM); - errorProto.setPrototype(nativeErrorProto); - ctor.setAttributes("name", DONTENUM | READONLY); - ctor.setAttributes("length", DONTENUM | READONLY); - if (sealed) { - errorProto.sealObject(); - ctor.sealObject(); - } - - ScriptableObject.defineProperty(scope, name, ctor, DONTENUM); - } - } - - private static void defineGlobalFunction( - VarScope scope, - boolean sealed, - String name, - int length, - SerializableCallable callable) { - LambdaFunction fun = new LambdaFunction(scope, name, length, null, callable); - registerGlobalFunction(scope, sealed, name, fun); - } - - private static void registerGlobalFunction( - VarScope scope, boolean sealed, String name, LambdaFunction fun) { - ScriptableObject.defineProperty(scope, name, fun, DONTENUM); - if (sealed) { - fun.sealObject(); + Function builtinErrorCtor = TopLevel.getBuiltinCtor(cx, scope, TopLevel.Builtins.Error); + for (var e : ERROR_DESCRIPTORS.entrySet()) { + var name = e.getKey().name(); + var desc = e.getValue(); + var errorProto = NativeError.makeProto(scope, builtinErrorCtor); + desc.buildConstructor( + cx, + scope, + errorProto, + sealed, + (c, ctor) -> { + ctor.setPrototype(nativeError); + errorProto.setPrototype(nativeErrorProto); + }); } } - // Eval is special because we need to "recognize" it in isEvalFunction - private static void defineGlobalFunctionEval(VarScope scope, boolean sealed) { - LambdaFunction evalFun = new EvalLambdaFunction(scope); - registerGlobalFunction(scope, sealed, "eval", evalFun); - } - static boolean isEvalFunction(Object functionObj) { - return functionObj instanceof EvalLambdaFunction; + return functionObj instanceof JSFunction + && ((JSFunction) functionObj).getDescriptor() == EVAL_DESCRIPTOR; } - private static String js_uneval(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static String js_uneval( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Object value = (args.length != 0) ? args[0] : Undefined.instance; - return ScriptRuntime.uneval(cx, scope, value); + return ScriptRuntime.uneval(cx, s, value); } - private static Boolean js_isXMLName(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Boolean js_isXMLName( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Object name = (args.length == 0) ? Undefined.instance : args[0]; - XMLLib xmlLib = XMLLib.extractFromScope(scope); + XMLLib xmlLib = XMLLib.extractFromScope(s); return xmlLib.isXMLName(cx, name); } - private static Boolean js_isNaN(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Boolean js_isNaN( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // The global method isNaN, as per ECMA-262 15.1.2.6. if (args.length < 1) { return true; @@ -186,48 +149,52 @@ private static Boolean js_isNaN(Context cx, VarScope scope, Object thisObj, Obje } } - private static Object js_isFinite(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_isFinite( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length < 1) { return Boolean.FALSE; } return NativeNumber.isFinite(args[0]); } - private static String js_decodeURI(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static String js_decodeURI( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(args, 0); return decode(str, true); } private static String js_decodeURIComponent( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(args, 0); return decode(str, false); } - private static String js_encodeURI(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static String js_encodeURI( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(args, 0); return encode(str, true); } private static String js_encodeURIComponent( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(args, 0); return encode(str, false); } /** The global method parseInt, as per ECMA-262 15.1.2.2. */ - static Object js_parseInt(Context cx, VarScope scope, Object thisObj, Object[] args) { - String s = ScriptRuntime.toString(args, 0); + static Object js_parseInt( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + String str = ScriptRuntime.toString(args, 0); int radix = ScriptRuntime.toInt32(args, 1); - int len = s.length(); + int len = str.length(); if (len == 0) return ScriptRuntime.NaNobj; boolean negative = false; int start = 0; char c; do { - c = s.charAt(start); + c = str.charAt(start); if (!ScriptRuntime.isStrWhiteSpaceChar(c)) break; start++; } while (start < len); @@ -239,15 +206,15 @@ static Object js_parseInt(Context cx, VarScope scope, Object thisObj, Object[] a radix = NO_RADIX; } else if (radix < 2 || radix > 36) { return ScriptRuntime.NaNobj; - } else if (radix == 16 && len - start > 1 && s.charAt(start) == '0') { - c = s.charAt(start + 1); + } else if (radix == 16 && len - start > 1 && str.charAt(start) == '0') { + c = str.charAt(start + 1); if (c == 'x' || c == 'X') start += 2; } if (radix == NO_RADIX) { radix = 10; - if (len - start > 1 && s.charAt(start) == '0') { - c = s.charAt(start + 1); + if (len - start > 1 && str.charAt(start) == '0') { + c = str.charAt(start + 1); if (c == 'x' || c == 'X') { radix = 16; start += 2; @@ -260,7 +227,7 @@ static Object js_parseInt(Context cx, VarScope scope, Object thisObj, Object[] a } } - double d = ScriptRuntime.stringPrefixToNumber(s, start, radix); + double d = ScriptRuntime.stringPrefixToNumber(str, start, radix); return negative ? -d : d; } @@ -269,11 +236,12 @@ static Object js_parseInt(Context cx, VarScope scope, Object thisObj, Object[] a * * @param args the arguments to parseFloat, ignoring args[>=1] */ - static Object js_parseFloat(Context cx, VarScope scope, Object thisObj, Object[] args) { + static Object js_parseFloat( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length < 1) return ScriptRuntime.NaNobj; - String s = ScriptRuntime.toString(args[0]); - int len = s.length(); + String str = ScriptRuntime.toString(args[0]); + int len = str.length(); int start = 0; // Scan forward to skip whitespace char c; @@ -281,7 +249,7 @@ static Object js_parseFloat(Context cx, VarScope scope, Object thisObj, Object[] if (start == len) { return ScriptRuntime.NaNobj; } - c = s.charAt(start); + c = str.charAt(start); if (!ScriptRuntime.isStrWhiteSpaceChar(c)) { break; } @@ -294,13 +262,13 @@ static Object js_parseFloat(Context cx, VarScope scope, Object thisObj, Object[] if (i == len) { return ScriptRuntime.NaNobj; } - c = s.charAt(i); + c = str.charAt(i); } if (c == 'I') { // check for "Infinity" - if (i + 8 <= len && s.regionMatches(i, "Infinity", 0, 8)) { - if (s.charAt(start) == '-') { + if (i + 8 <= len && str.regionMatches(i, "Infinity", 0, 8)) { + if (str.charAt(start) == '-') { return Double.NEGATIVE_INFINITY; } else { return Double.POSITIVE_INFINITY; @@ -314,7 +282,7 @@ static Object js_parseFloat(Context cx, VarScope scope, Object thisObj, Object[] int exponent = -1; boolean exponentValid = false; for (; i < len; i++) { - switch (s.charAt(i)) { + switch (str.charAt(i)) { case '.': if (decimal != -1) // Only allow a single decimal point. break; @@ -365,9 +333,9 @@ static Object js_parseFloat(Context cx, VarScope scope, Object thisObj, Object[] if (exponent != -1 && !exponentValid) { i = exponent; } - s = s.substring(start, i); + str = str.substring(start, i); try { - return Double.valueOf(s); + return Double.valueOf(str); } catch (NumberFormatException ex) { return ScriptRuntime.NaNobj; } @@ -379,10 +347,11 @@ static Object js_parseFloat(Context cx, VarScope scope, Object thisObj, Object[] *

Includes code for the 'mask' argument supported by the C escape method, which used to be * part of the browser embedding. Blame for the strange constant names should be directed there. */ - private static Object js_escape(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_escape( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { final int URL_XALPHAS = 1, URL_XPALPHAS = 2, URL_PATH = 4; - String s = ScriptRuntime.toString(args, 0); + String str = ScriptRuntime.toString(args, 0); int mask = URL_XALPHAS | URL_XPALPHAS | URL_PATH; if (args.length > 1) { // the 'mask' argument. Non-ECMA. @@ -395,8 +364,8 @@ private static Object js_escape(Context cx, VarScope scope, Object thisObj, Obje } StringBuilder sb = null; - for (int k = 0, L = s.length(); k != L; ++k) { - int c = s.charAt(k); + for (int k = 0, L = str.length(); k != L; ++k) { + int c = str.charAt(k); if (mask != 0 && ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') @@ -440,16 +409,17 @@ private static Object js_escape(Context cx, VarScope scope, Object thisObj, Obje } } - return (sb == null) ? s : sb.toString(); + return (sb == null) ? str : sb.toString(); } /** The global unescape method, as per ECMA-262 15.1.2.5. */ - private static Object js_unescape(Context cx, VarScope scope, Object thisObj, Object[] args) { - String s = ScriptRuntime.toString(args, 0); - int firstEscapePos = s.indexOf('%'); + private static Object js_unescape( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + String str = ScriptRuntime.toString(args, 0); + int firstEscapePos = str.indexOf('%'); if (firstEscapePos >= 0) { - int L = s.length(); - char[] buf = s.toCharArray(); + int L = str.length(); + char[] buf = str.toCharArray(); int destination = firstEscapePos; for (int k = firstEscapePos; k != L; ) { char c = buf[k]; @@ -477,17 +447,18 @@ private static Object js_unescape(Context cx, VarScope scope, Object thisObj, Ob buf[destination] = c; ++destination; } - s = new String(buf, 0, destination); + str = new String(buf, 0, destination); } - return s; + return str; } /** * This is an indirect call to eval, and thus uses the global environment. Direct calls are * executed via ScriptRuntime.callSpecial(). */ - private static Object js_eval(Context cx, VarScope scope, Object[] args) { - TopLevel top = ScriptableObject.getTopLevelScope(scope); + private static Object js_eval( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + TopLevel top = ScriptableObject.getTopLevelScope(f.getDeclarationScope()); return ScriptRuntime.evalSpecial(cx, top, top.getGlobalThis(), args, "eval code", 1); } @@ -740,20 +711,4 @@ private static int oneUcs4ToUtf8Char(byte[] utf8Buffer, int ucs4Char) { } return utf8Length; } - - /** - * A simple subclass of {@link LambdaFunction} used to "tag" eval, so that we can recognize it - * in {@link NativeGlobal#isEvalFunction} - */ - private static class EvalLambdaFunction extends LambdaFunction { - public EvalLambdaFunction(VarScope scope) { - super( - scope, - "eval", - 1, - null, - (callCx, callScope, thisObj, args) -> - NativeGlobal.js_eval(callCx, callScope, args)); - } - } } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeIterator.java b/rhino/src/main/java/org/mozilla/javascript/NativeIterator.java index ccbd64a74b9..6c3404897b1 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeIterator.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeIterator.java @@ -6,6 +6,8 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + import java.util.Iterator; /** @@ -21,48 +23,44 @@ public final class NativeIterator extends ScriptableObject { private Object objectIterator; + private static final String STOP_ITERATION = "StopIteration"; + public static final String ITERATOR_PROPERTY_NAME = "__iterator__"; + + private static final ClassDescriptor DESCRIPTOR; + + private static final ClassDescriptor STOP_ITER_DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 2, + NativeIterator::jsConstructorCall, + NativeIterator::jsConstructor) + .withMethod(PROTO, "next", 0, NativeIterator::js_next) + .withMethod( + PROTO, ITERATOR_PROPERTY_NAME, 1, NativeIterator::js_iteratorMethod) + .build(); + STOP_ITER_DESCRIPTOR = new ClassDescriptor.Builder(STOP_ITERATION, 0, null, null).build(); + } + static void init(Context cx, TopLevel scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - CLASS_NAME, - 2, - NativeIterator::jsConstructorCall, - NativeIterator::jsConstructor); - constructor.setPrototypePropertyAttributes(PERMANENT | READONLY | DONTENUM); - - NativeIterator proto = new NativeIterator(); - constructor.setPrototypeScriptable(proto); - - constructor.definePrototypeMethod(scope, "next", 0, NativeIterator::js_next); - constructor.definePrototypeMethod( - scope, ITERATOR_PROPERTY_NAME, 1, NativeIterator::js_iteratorMethod); - - ScriptableObject.defineProperty(scope, CLASS_NAME, constructor, ScriptableObject.DONTENUM); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } + NativeObject proto = new NativeObject(); + var ctor = DESCRIPTOR.buildConstructor(cx, scope, proto, sealed); // Generator if (cx.getLanguageVersion() >= Context.VERSION_ES6) { - ES6Generator.init(scope, sealed); + ES6Generator.init(cx, scope, sealed); } else { - NativeGenerator.init(scope, sealed); + NativeGenerator.init(cx, scope, sealed); } // StopIteration - NativeObject obj = new StopIteration(); - obj.setPrototype(getObjectPrototype(scope)); - obj.setParentScope(scope); - if (sealed) { - obj.sealObject(); - } - ScriptableObject.defineProperty(scope, STOP_ITERATION, obj, ScriptableObject.DONTENUM); + var stopCtor = STOP_ITER_DESCRIPTOR.populateGlobal(cx, scope, new StopIteration(), sealed); // Use "associateValue" so that generators can continue to // throw StopIteration even if the property of the global // scope is replaced or deleted. - scope.associateValue(ITERATOR_TAG, obj); + scope.associateValue(ITERATOR_TAG, stopCtor); } /** Only for constructing the prototype object. */ @@ -85,9 +83,6 @@ public static Object getStopIterationObject(VarScope scope) { return ScriptableObject.getTopScopeValue(top, ITERATOR_TAG); } - private static final String STOP_ITERATION = "StopIteration"; - public static final String ITERATOR_PROPERTY_NAME = "__iterator__"; - public static class StopIteration extends NativeObject { private static final long serialVersionUID = 2485151085722377663L; @@ -123,13 +118,13 @@ public String getClassName() { } private static Object jsConstructorCall( - Context cx, VarScope scope, Object thisObj, Object[] args) { - Scriptable target = requireIteratorTarget(cx, scope, args); + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + Scriptable target = requireIteratorTarget(cx, s, args); boolean keyOnly = isKeyOnly(args); Iterator iterator = getJavaIterator(target); if (iterator != null) { - VarScope topScope = ScriptableObject.getTopLevelScope(scope); + VarScope topScope = ScriptableObject.getTopLevelScope(s); return cx.getWrapFactory() .wrap( cx, @@ -143,13 +138,14 @@ private static Object jsConstructorCall( return jsIterator; } - return createNativeIterator(cx, scope, target, keyOnly); + return createNativeIterator(cx, s, target, keyOnly); } - private static Scriptable jsConstructor(Context cx, VarScope scope, Object[] args) { - Scriptable target = requireIteratorTarget(cx, scope, args); + private static Scriptable jsConstructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + Scriptable target = requireIteratorTarget(cx, s, args); boolean keyOnly = isKeyOnly(args); - return createNativeIterator(cx, scope, target, keyOnly); + return createNativeIterator(cx, s, target, keyOnly); } private static Scriptable requireIteratorTarget(Context cx, VarScope scope, Object[] args) { @@ -165,9 +161,10 @@ private static boolean isKeyOnly(Object[] args) { return args.length > 1 && ScriptRuntime.toBoolean(args[1]); } - private static Object js_next(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_next( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeIterator iterator = realThis(thisObj); - return iterator.next(cx, scope); + return iterator.next(cx, s); } private static NativeIterator createNativeIterator( @@ -188,7 +185,7 @@ private static NativeIterator createNativeIterator( } private static Object js_iteratorMethod( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj); } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeJSON.java b/rhino/src/main/java/org/mozilla/javascript/NativeJSON.java index 1c70459eb3e..965feb3df12 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeJSON.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeJSON.java @@ -6,6 +6,9 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; + import java.lang.reflect.Array; import java.math.BigInteger; import java.util.ArrayDeque; @@ -30,21 +33,21 @@ public final class NativeJSON extends ScriptableObject { private static final int MAX_STRINGIFY_GAP_LENGTH = 10; - static Object init(Context cx, VarScope scope, boolean sealed) { - NativeJSON json = new NativeJSON(); - json.setPrototype(getObjectPrototype(scope)); - json.setParentScope(scope); - - json.defineBuiltinProperty(scope, "parse", 2, NativeJSON::parse); - json.defineBuiltinProperty(scope, "stringify", 3, NativeJSON::stringify); - - json.defineProperty("toSource", "JSON", DONTENUM | READONLY | PERMANENT); + private static final ClassDescriptor DESCRIPTION; + + static { + DESCRIPTION = + new ClassDescriptor.Builder(JSON_TAG) + .withMethod(CTOR, "parse", 2, NativeJSON::parse) + .withMethod(CTOR, "stringify", 3, NativeJSON::stringify) + .withProp(CTOR, "toSource", value("JSON")) + .withProp( + CTOR, SymbolKey.TO_STRING_TAG, value(JSON_TAG, DONTENUM | READONLY)) + .build(); + } - json.defineProperty(SymbolKey.TO_STRING_TAG, JSON_TAG, DONTENUM | READONLY); - if (sealed) { - json.sealObject(); - } - return json; + static Object init(Context cx, VarScope scope, boolean sealed) { + return DESCRIPTION.populateGlobal(cx, scope, new NativeJSON(), sealed); } private NativeJSON() {} @@ -54,19 +57,21 @@ public String getClassName() { return "JSON"; } - private static Object parse(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object parse( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String jtext = ScriptRuntime.toString(args, 0); Object reviver = null; if (args.length > 1) { reviver = args[1]; } if (reviver instanceof Callable) { - return parse(cx, scope, jtext, (Callable) reviver); + return parse(cx, f.getDeclarationScope(), jtext, (Callable) reviver); } - return parse(cx, scope, jtext); + return parse(cx, f.getDeclarationScope(), jtext); } - private static Object stringify(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object stringify( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Object value = Undefined.instance, replacer = null, space = null; if (args.length > 0) { @@ -78,7 +83,7 @@ private static Object stringify(Context cx, VarScope scope, Object thisObj, Obje } } } - return stringify(cx, scope, value, replacer, space); + return stringify(cx, s, value, replacer, space); } private static Object parse(Context cx, VarScope scope, String jtext) { diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeJavaClass.java b/rhino/src/main/java/org/mozilla/javascript/NativeJavaClass.java index 1b34ad1787d..080e1bd2f8a 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeJavaClass.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeJavaClass.java @@ -116,7 +116,7 @@ public Object getDefaultValue(Class hint) { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { // If it looks like a "cast" of an object to this class type, // walk the prototype chain to see if there's a wrapper of a // object that's an instanceof this class. @@ -180,6 +180,10 @@ public Scriptable construct(Context cx, VarScope scope, Object[] args) { throw Context.reportRuntimeErrorById("msg.cant.instantiate", msg, classObject.getName()); } + public Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object args[]) { + return construct(cx, s, args); + } + static Scriptable constructSpecific( Context cx, VarScope scope, Object[] args, ExecutableBox ctor) { Object instance = constructInternal(args, ctor); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeJavaConstructor.java b/rhino/src/main/java/org/mozilla/javascript/NativeJavaConstructor.java index 810221989cc..19aed2c415b 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeJavaConstructor.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeJavaConstructor.java @@ -25,12 +25,13 @@ public class NativeJavaConstructor extends BaseFunction { ExecutableBox ctor; - public NativeJavaConstructor(ExecutableBox ctor) { + public NativeJavaConstructor(VarScope scope, ExecutableBox ctor) { + super(scope); this.ctor = ctor; } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { return NativeJavaClass.constructSpecific(cx, scope, args, ctor); } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeJavaMap.java b/rhino/src/main/java/org/mozilla/javascript/NativeJavaMap.java index 7b4d86a449f..21a0cc50fe9 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeJavaMap.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeJavaMap.java @@ -30,8 +30,8 @@ public class NativeJavaMap extends NativeJavaObject { private final TypeInfo keyType; private final TypeInfo valueType; - static void init(TopLevel scope, boolean sealed) { - NativeJavaMapIterator.init(scope, sealed); + static void init(Context cx, TopLevel scope, boolean sealed) { + NativeJavaMapIterator.init(cx, scope, sealed); } @SuppressWarnings("unchecked") @@ -160,7 +160,7 @@ public int hashCode() { } private static Callable symbol_iterator = - (Context cx, VarScope scope, Scriptable thisObj, Object[] args) -> { + (cx, scope, thisObj, args) -> { if (!(thisObj instanceof NativeJavaMap)) { throw ScriptRuntime.typeErrorById("msg.incompat.call", SymbolKey.ITERATOR); } @@ -168,11 +168,20 @@ public int hashCode() { }; private static final class NativeJavaMapIterator extends ES6Iterator { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -6354388021424261488L; private static final String ITERATOR_TAG = "JavaMapIterator"; - static void init(TopLevel scope, boolean sealed) { - ES6Iterator.init(scope, sealed, new NativeJavaMapIterator(), ITERATOR_TAG); + private static final ClassDescriptor DESCRIPTOR = + ES6Iterator.makeDescriptor(ITERATOR_TAG, "Java Map Iterator"); + + static void init(Context cx, VarScope scope, boolean sealed) { + ES6Iterator.initialize( + DESCRIPTOR, + cx, + (TopLevel) scope, + new NativeJavaMapIterator(), + sealed, + ITERATOR_TAG); } /** Only for constructing the prototype object. */ diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeJavaMethod.java b/rhino/src/main/java/org/mozilla/javascript/NativeJavaMethod.java index 8a71ae9cabf..e5724c30514 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeJavaMethod.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeJavaMethod.java @@ -37,19 +37,24 @@ public class NativeJavaMethod extends BaseFunction { private final transient CopyOnWriteArrayList overloadCache = new CopyOnWriteArrayList<>(); - NativeJavaMethod(ExecutableBox[] methods, String name) { + NativeJavaMethod(VarScope scope, ExecutableBox[] methods, String name) { + super(scope); this.functionName = name; this.methods = methods; } - NativeJavaMethod(ExecutableBox method, String name) { + NativeJavaMethod(VarScope scope, ExecutableBox method, String name) { + super(scope); this.functionName = name; this.methods = new ExecutableBox[] {method}; } @Deprecated public NativeJavaMethod(VarScope scope, Method method, String name) { - this(new ExecutableBox(method, TypeInfoFactory.GLOBAL, method.getDeclaringClass()), name); + this( + scope, + new ExecutableBox(method, TypeInfoFactory.GLOBAL, method.getDeclaringClass()), + name); } @Override @@ -129,7 +134,7 @@ public String toString() { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { // Find a method that matches the types given. if (methods.length == 0) { throw new RuntimeException("No methods defined for call"); @@ -159,7 +164,7 @@ public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args if (meth.isStatic()) { javaObject = null; // don't need an object } else { - Scriptable o = thisObj; + Scriptable o = ScriptRuntime.toObject(getDeclarationScope(), thisObj); Class c = meth.getDeclaringClass(); for (; ; ) { if (o == null) { diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeJavaObject.java b/rhino/src/main/java/org/mozilla/javascript/NativeJavaObject.java index 20bccc80d91..a78ed395992 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeJavaObject.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeJavaObject.java @@ -35,8 +35,8 @@ public class NativeJavaObject implements Scriptable, SymbolScriptable, Wrapper, private static final long serialVersionUID = -6948590651130498591L; - static void init(TopLevel scope, boolean sealed) { - JavaIterableIterator.init(scope, sealed); + static void init(Context cx, TopLevel scope, boolean sealed) { + JavaIterableIterator.init(cx, scope, sealed); } public NativeJavaObject() {} @@ -904,7 +904,7 @@ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundE } private static Callable symbol_iterator = - (Context cx, VarScope scope, Scriptable thisObj, Object[] args) -> { + (cx, scope, thisObj, args) -> { if (!(thisObj instanceof NativeJavaObject)) { throw ScriptRuntime.typeErrorById("msg.incompat.call", SymbolKey.ITERATOR); } @@ -916,11 +916,15 @@ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundE }; private static final class JavaIterableIterator extends ES6Iterator { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -2636492890037940863L; private static final String ITERATOR_TAG = "JavaIterableIterator"; - static void init(TopLevel scope, boolean sealed) { - ES6Iterator.init(scope, sealed, new JavaIterableIterator(), ITERATOR_TAG); + private static final ClassDescriptor DESCRIPTOR = + ES6Iterator.makeDescriptor(ITERATOR_TAG, "Java Iterable Iterator"); + + static void init(Context cx, TopLevel scope, boolean sealed) { + ES6Iterator.initialize( + DESCRIPTOR, cx, scope, new JavaIterableIterator(), sealed, ITERATOR_TAG); } /** Only for constructing the prototype object. */ diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeJavaTopPackage.java b/rhino/src/main/java/org/mozilla/javascript/NativeJavaTopPackage.java index 517d2b79195..85cc53c576c 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeJavaTopPackage.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeJavaTopPackage.java @@ -38,7 +38,7 @@ public class NativeJavaTopPackage extends NativeJavaPackage implements Function, } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { return construct(cx, scope, args); } @@ -63,6 +63,10 @@ public Scriptable construct(Context cx, VarScope scope, Object[] args) { return pkg; } + public Scriptable construct(Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { + return construct(cx, s, args); + } + public static void init(Context cx, VarScope scope, boolean sealed) { ClassLoader loader = cx.getApplicationClassLoader(); final NativeJavaTopPackage top = new NativeJavaTopPackage(loader); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeMap.java b/rhino/src/main/java/org/mozilla/javascript/NativeMap.java index 2c09bbd68df..c9ee3b7d76a 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeMap.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeMap.java @@ -6,6 +6,11 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.alias; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + import java.util.List; import java.util.Map; @@ -14,60 +19,61 @@ public class NativeMap extends ScriptableObject { private static final String CLASS_NAME = "Map"; static final String ITERATOR_TAG = "Map Iterator"; + private static final ClassDescriptor DESCRIPTOR; + private static final ClassDescriptor ITER_DESCRIPTOR = + ES6Iterator.makeDescriptor(ITERATOR_TAG, ITERATOR_TAG); + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 0, + ClassDescriptor.typeError(), + NativeMap::js_constructor) + .withMethod(CTOR, "groupBy", 2, NativeMap::jsGroupBy) + .withMethod(PROTO, "set", 2, NativeMap::js_set) + .withMethod(PROTO, "delete", 1, NativeMap::js_delete) + .withMethod(PROTO, "get", 1, NativeMap::js_get) + .withMethod(PROTO, "has", 1, NativeMap::js_has) + .withMethod(PROTO, "clear", 0, NativeMap::js_clear) + .withMethod(PROTO, "keys", 0, NativeMap::js_keys) + .withMethod(PROTO, "values", 0, NativeMap::js_values) + .withMethod(PROTO, "forEach", 1, NativeMap::js_forEach) + .withMethod(PROTO, "entries", 0, NativeMap::js_entries) + .withProp(PROTO, SymbolKey.ITERATOR, alias("entries", DONTENUM)) + .withProp( + PROTO, + "size", + (thisObj) -> realThis(thisObj, "size").js_getSize(), + null, + DONTENUM) + .withProp( + PROTO, + NativeSet.GETSIZE, + (thisObj) -> realThis(thisObj, "size").js_getSize(), + null, + DONTENUM | PERMANENT) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value(CLASS_NAME, DONTENUM | READONLY)) + .withProp(CTOR, SymbolKey.SPECIES, ScriptRuntimeES6::symbolSpecies) + .build(); + } + private final Hashtable entries = new Hashtable(); private boolean instanceOfMap = false; static Object init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - CLASS_NAME, - 0, - LambdaConstructor.CONSTRUCTOR_NEW, - NativeMap::jsConstructor); - constructor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - - constructor.defineConstructorMethod(scope, "groupBy", 2, NativeMap::jsGroupBy); - - constructor.definePrototypeMethod(scope, "set", 2, NativeMap::js_set); - constructor.definePrototypeMethod(scope, "delete", 1, NativeMap::js_delete); - constructor.definePrototypeMethod(scope, "get", 1, NativeMap::js_get); - constructor.definePrototypeMethod(scope, "has", 1, NativeMap::js_has); - constructor.definePrototypeMethod(scope, "clear", 0, NativeMap::js_clear); - constructor.definePrototypeMethod(scope, "keys", 0, NativeMap::js_keys); - constructor.definePrototypeMethod(scope, "values", 0, NativeMap::js_values); - constructor.definePrototypeMethod(scope, "forEach", 1, NativeMap::js_forEach); - - constructor.definePrototypeMethod(scope, "entries", 0, NativeMap::js_entries); - constructor.definePrototypeAlias("entries", SymbolKey.ITERATOR, DONTENUM); - - // The spec requires very specific handling of the "size" prototype - // property that's not like other things that we already do. - ScriptableObject desc = (ScriptableObject) cx.newObject(scope); - desc.put("enumerable", desc, Boolean.FALSE); - desc.put("configurable", desc, Boolean.TRUE); - LambdaFunction sizeFunc = - new LambdaFunction( - scope, - "get size", - 0, - (Context lcx, VarScope lscope, Scriptable thisObj, Object[] args) -> - realThis(thisObj, "size").js_getSize(), - false); - desc.put("get", desc, sizeFunc); - constructor.definePrototypeProperty(cx, "size", desc); - constructor.definePrototypeProperty(cx, NativeSet.GETSIZE, desc); - - constructor.definePrototypeProperty( - SymbolKey.TO_STRING_TAG, CLASS_NAME, DONTENUM | READONLY); - - ScriptRuntimeES6.addSymbolSpecies(cx, scope, constructor); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } - return constructor; + ES6Iterator.initialize( + ITER_DESCRIPTOR, + cx, + (TopLevel) scope, + new NativeCollectionIterator(ITERATOR_TAG), + sealed, + ITERATOR_TAG); + return DESCRIPTOR.buildConstructor(cx, scope, new NativeObject(), sealed); } @Override @@ -75,40 +81,44 @@ public String getClassName() { return CLASS_NAME; } - private static Scriptable jsConstructor(Context cx, VarScope scope, Object[] args) { + private static Scriptable js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeMap nm = new NativeMap(); nm.instanceOfMap = true; if (args.length > 0) { - loadFromIterable(cx, scope, nm, key(args)); + loadFromIterable(cx, s, nm, key(args)); } + ScriptRuntime.setBuiltinProtoAndParent(nm, f, nt, s, TopLevel.Builtins.Map); return nm; } - private static Object jsGroupBy(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object jsGroupBy( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Object items = args.length < 1 ? Undefined.instance : args[0]; Object callback = args.length < 2 ? Undefined.instance : args[1]; Map> groups = AbstractEcmaObjectOperations.groupBy( cx, - scope, + s, CLASS_NAME, "groupBy", items, callback, AbstractEcmaObjectOperations.KEY_COERCION.COLLECTION); - NativeMap map = (NativeMap) cx.newObject(scope, "Map"); + NativeMap map = (NativeMap) cx.newObject(s, "Map"); for (Map.Entry> entry : groups.entrySet()) { - Scriptable elements = cx.newArray(scope, entry.getValue().toArray()); + Scriptable elements = cx.newArray(s, entry.getValue().toArray()); map.entries.put(entry.getKey(), elements); } return map; } - private static Object js_set(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_set( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "set") .js_set(key(args), args.length > 1 ? args[1] : Undefined.instance); } @@ -123,7 +133,8 @@ private Object js_set(Object k, Object v) { return this; } - private static Object js_delete(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_delete( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "delete").js_delete(key(args)); } @@ -131,7 +142,8 @@ private Object js_delete(Object arg) { return entries.deleteEntry(arg); } - private static Object js_get(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_get( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "get").js_get(key(args)); } @@ -143,7 +155,8 @@ private Object js_get(Object arg) { return entry.value; } - private static Object js_has(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_has( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "has").js_has(key(args)); } @@ -155,23 +168,30 @@ private Object js_getSize() { return entries.size(); } - private static Object js_keys(Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "keys").js_iterator(scope, NativeCollectionIterator.Type.KEYS); + private static Object js_keys( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "keys") + .js_iterator(f.getDeclarationScope(), NativeCollectionIterator.Type.KEYS); } - private static Object js_values(Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "values").js_iterator(scope, NativeCollectionIterator.Type.VALUES); + private static Object js_values( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "values") + .js_iterator(f.getDeclarationScope(), NativeCollectionIterator.Type.VALUES); } - private static Object js_entries(Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "entries").js_iterator(scope, NativeCollectionIterator.Type.BOTH); + private static Object js_entries( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "entries") + .js_iterator(f.getDeclarationScope(), NativeCollectionIterator.Type.BOTH); } private Object js_iterator(VarScope scope, NativeCollectionIterator.Type type) { return new NativeCollectionIterator(scope, ITERATOR_TAG, type, entries.iterator()); } - private static Object js_clear(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_clear( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "clear").js_clear(); } @@ -181,11 +201,11 @@ private Object js_clear() { } private static Object js_forEach( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "forEach") .js_forEach( cx, - scope, + s, args.length > 0 ? args[0] : Undefined.instance, args.length > 1 ? args[1] : Undefined.instance); } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeMath.java b/rhino/src/main/java/org/mozilla/javascript/NativeMath.java index c20590ffbef..c1b732e2304 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeMath.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeMath.java @@ -6,6 +6,9 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; + /** * This class implements the Math native object. See ECMA 15.8. * @@ -18,64 +21,62 @@ final class NativeMath extends ScriptableObject { private static final double LOG2E = 1.4426950408889634; private static final Double Double32 = Double.valueOf(32d); + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder(MATH_TAG) + .withProp(CTOR, "toSource", value("Math")) + .withMethod(CTOR, "abs", 1, NativeMath::abs) + .withMethod(CTOR, "acos", 1, NativeMath::acos) + .withMethod(CTOR, "acosh", 1, NativeMath::acosh) + .withMethod(CTOR, "asin", 1, NativeMath::asin) + .withMethod(CTOR, "asinh", 1, NativeMath::asinh) + .withMethod(CTOR, "atan", 1, NativeMath::atan) + .withMethod(CTOR, "atanh", 1, NativeMath::atanh) + .withMethod(CTOR, "atan2", 2, NativeMath::atan2) + .withMethod(CTOR, "cbrt", 1, NativeMath::cbrt) + .withMethod(CTOR, "ceil", 1, NativeMath::ceil) + .withMethod(CTOR, "clz32", 1, NativeMath::clz32) + .withMethod(CTOR, "cos", 1, NativeMath::cos) + .withMethod(CTOR, "cosh", 1, NativeMath::cosh) + .withMethod(CTOR, "exp", 1, NativeMath::exp) + .withMethod(CTOR, "expm1", 1, NativeMath::expm1) + .withMethod(CTOR, "f16round", 1, NativeMath::f16round) + .withMethod(CTOR, "floor", 1, NativeMath::floor) + .withMethod(CTOR, "fround", 1, NativeMath::fround) + .withMethod(CTOR, "hypot", 2, NativeMath::hypot) + .withMethod(CTOR, "imul", 2, NativeMath::imul) + .withMethod(CTOR, "log", 1, NativeMath::log) + .withMethod(CTOR, "log1p", 1, NativeMath::log1p) + .withMethod(CTOR, "log10", 1, NativeMath::log10) + .withMethod(CTOR, "log2", 1, NativeMath::log2) + .withMethod(CTOR, "max", 2, NativeMath::max) + .withMethod(CTOR, "min", 2, NativeMath::min) + .withMethod(CTOR, "pow", 2, NativeMath::pow) + .withMethod(CTOR, "random", 0, NativeMath::random) + .withMethod(CTOR, "round", 1, NativeMath::round) + .withMethod(CTOR, "sign", 1, NativeMath::sign) + .withMethod(CTOR, "sin", 1, NativeMath::sin) + .withMethod(CTOR, "sinh", 1, NativeMath::sinh) + .withMethod(CTOR, "sqrt", 1, NativeMath::sqrt) + .withMethod(CTOR, "tan", 1, NativeMath::tan) + .withMethod(CTOR, "tanh", 1, NativeMath::tanh) + .withMethod(CTOR, "trunc", 1, NativeMath::trunc) + .withProp(CTOR, "E", value(Math.E)) + .withProp(CTOR, "PI", value(Math.PI)) + .withProp(CTOR, "LN10", value(2.302585092994046)) + .withProp(CTOR, "LN2", value(0.6931471805599453)) + .withProp(CTOR, "LOG2E", value(LOG2E)) + .withProp(CTOR, "LOG10E", value(0.4342944819032518)) + .withProp(CTOR, "SQRT1_2", value(0.7071067811865476)) + .withProp(CTOR, "SQRT2", value(1.4142135623730951)) + .withProp(CTOR, SymbolKey.TO_STRING_TAG, value("Math", DONTENUM | READONLY)) + .build(); + } + static Object init(Context cx, VarScope scope, boolean sealed) { - NativeMath math = new NativeMath(); - math.setPrototype(getObjectPrototype(scope)); - math.setParentScope(scope); - - math.defineProperty("toSource", "Math", DONTENUM | READONLY | PERMANENT); - - math.defineBuiltinProperty(scope, "abs", 1, NativeMath::abs); - math.defineBuiltinProperty(scope, "acos", 1, NativeMath::acos); - math.defineBuiltinProperty(scope, "acosh", 1, NativeMath::acosh); - math.defineBuiltinProperty(scope, "asin", 1, NativeMath::asin); - math.defineBuiltinProperty(scope, "asinh", 1, NativeMath::asinh); - math.defineBuiltinProperty(scope, "atan", 1, NativeMath::atan); - math.defineBuiltinProperty(scope, "atanh", 1, NativeMath::atanh); - math.defineBuiltinProperty(scope, "atan2", 2, NativeMath::atan2); - math.defineBuiltinProperty(scope, "cbrt", 1, NativeMath::cbrt); - math.defineBuiltinProperty(scope, "ceil", 1, NativeMath::ceil); - math.defineBuiltinProperty(scope, "clz32", 1, NativeMath::clz32); - math.defineBuiltinProperty(scope, "cos", 1, NativeMath::cos); - math.defineBuiltinProperty(scope, "cosh", 1, NativeMath::cosh); - math.defineBuiltinProperty(scope, "exp", 1, NativeMath::exp); - math.defineBuiltinProperty(scope, "expm1", 1, NativeMath::expm1); - math.defineBuiltinProperty(scope, "f16round", 1, NativeMath::f16round); - math.defineBuiltinProperty(scope, "floor", 1, NativeMath::floor); - math.defineBuiltinProperty(scope, "fround", 1, NativeMath::fround); - math.defineBuiltinProperty(scope, "hypot", 2, NativeMath::hypot); - math.defineBuiltinProperty(scope, "imul", 2, NativeMath::imul); - math.defineBuiltinProperty(scope, "log", 1, NativeMath::log); - math.defineBuiltinProperty(scope, "log1p", 1, NativeMath::log1p); - math.defineBuiltinProperty(scope, "log10", 1, NativeMath::log10); - math.defineBuiltinProperty(scope, "log2", 1, NativeMath::log2); - math.defineBuiltinProperty(scope, "max", 2, NativeMath::max); - math.defineBuiltinProperty(scope, "min", 2, NativeMath::min); - math.defineBuiltinProperty(scope, "pow", 2, NativeMath::pow); - math.defineBuiltinProperty(scope, "random", 0, NativeMath::random); - math.defineBuiltinProperty(scope, "round", 1, NativeMath::round); - math.defineBuiltinProperty(scope, "sign", 1, NativeMath::sign); - math.defineBuiltinProperty(scope, "sin", 1, NativeMath::sin); - math.defineBuiltinProperty(scope, "sinh", 1, NativeMath::sinh); - math.defineBuiltinProperty(scope, "sqrt", 1, NativeMath::sqrt); - math.defineBuiltinProperty(scope, "tan", 1, NativeMath::tan); - math.defineBuiltinProperty(scope, "tanh", 1, NativeMath::tanh); - math.defineBuiltinProperty(scope, "trunc", 1, NativeMath::trunc); - - math.defineProperty("E", Math.E, DONTENUM | READONLY | PERMANENT); - math.defineProperty("PI", Math.PI, DONTENUM | READONLY | PERMANENT); - math.defineProperty("LN10", 2.302585092994046, DONTENUM | READONLY | PERMANENT); - math.defineProperty("LN2", 0.6931471805599453, DONTENUM | READONLY | PERMANENT); - math.defineProperty("LOG2E", LOG2E, DONTENUM | READONLY | PERMANENT); - math.defineProperty("LOG10E", 0.4342944819032518, DONTENUM | READONLY | PERMANENT); - math.defineProperty("SQRT1_2", 0.7071067811865476, DONTENUM | READONLY | PERMANENT); - math.defineProperty("SQRT2", 1.4142135623730951, DONTENUM | READONLY | PERMANENT); - - math.defineProperty(SymbolKey.TO_STRING_TAG, MATH_TAG, DONTENUM | READONLY); - if (sealed) { - math.sealObject(); - } - return math; + return DESCRIPTOR.populateGlobal(cx, scope, new NativeMath(), sealed); } private NativeMath() {} @@ -85,7 +86,8 @@ public String getClassName() { return "Math"; } - private static Object abs(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object abs( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); // abs(-0.0) should be 0.0, but -0.0 < 0.0 == false x = (x == 0.0) ? 0.0 : (x < 0.0) ? -x : x; @@ -93,7 +95,8 @@ private static Object abs(Context cx, VarScope scope, Object thisObj, Object[] a return ScriptRuntime.wrapNumber(x); } - private static Object acos(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object acos( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (!Double.isNaN(x) && -1.0 <= x && x <= 1.0) { x = Math.acos(x); @@ -103,7 +106,8 @@ private static Object acos(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.wrapNumber(x); } - private static Object acosh(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object acosh( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (!Double.isNaN(x)) { return Double.valueOf(Math.log(x + Math.sqrt(x * x - 1.0))); @@ -111,7 +115,8 @@ private static Object acosh(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.NaNobj; } - private static Object asin(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object asin( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (!Double.isNaN(x) && -1.0 <= x && x <= 1.0) { x = Math.asin(x); @@ -121,7 +126,8 @@ private static Object asin(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.wrapNumber(x); } - private static Object asinh(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object asinh( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (Double.isInfinite(x)) { return Double.valueOf(x); @@ -138,13 +144,15 @@ private static Object asinh(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.NaNobj; } - private static Object atan(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object atan( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.atan(x); return ScriptRuntime.wrapNumber(x); } - private static Object atanh(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object atanh( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (!Double.isNaN(x) && -1.0 <= x && x <= 1.0) { if (x == 0) { @@ -158,25 +166,29 @@ private static Object atanh(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.NaNobj; } - private static Object atan2(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object atan2( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.atan2(x, ScriptRuntime.toNumber(args, 1)); return ScriptRuntime.wrapNumber(x); } - private static Object cbrt(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object cbrt( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.cbrt(x); return ScriptRuntime.wrapNumber(x); } - private static Object ceil(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object ceil( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.ceil(x); return ScriptRuntime.wrapNumber(x); } - private static Object clz32(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object clz32( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (x == 0 || Double.isNaN(x) || Double.isInfinite(x)) { return Double32; @@ -214,19 +226,22 @@ private static Object clz32(Context cx, VarScope scope, Object thisObj, Object[] return Double.valueOf(32 - place); } - private static Object cos(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object cos( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Double.isInfinite(x) ? Double.NaN : Math.cos(x); return ScriptRuntime.wrapNumber(x); } - private static Object cosh(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object cosh( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.cosh(x); return ScriptRuntime.wrapNumber(x); } - private static Object exp(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object exp( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = (x == Double.POSITIVE_INFINITY) @@ -235,19 +250,22 @@ private static Object exp(Context cx, VarScope scope, Object thisObj, Object[] a return ScriptRuntime.wrapNumber(x); } - private static Object expm1(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object expm1( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.expm1(x); return ScriptRuntime.wrapNumber(x); } - private static Object floor(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object floor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.floor(x); return ScriptRuntime.wrapNumber(x); } - private static Object f16round(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object f16round( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // Handle missing arguments if (args.length == 0) { return ScriptRuntime.NaNobj; @@ -392,7 +410,8 @@ private static Object reconstructNormalF16(int sign, int exponent, long mantissa return ScriptRuntime.wrapNumber(Double.longBitsToDouble(resultBits)); } - private static Object fround(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object fround( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); // Rely on Java to truncate down to a "float" here" float fx = (float) x; @@ -401,7 +420,8 @@ private static Object fround(Context cx, VarScope scope, Object thisObj, Object[ // Based on code from // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot - private static Object hypot(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object hypot( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args == null) { return 0.0; } @@ -431,7 +451,8 @@ private static Object hypot(Context cx, VarScope scope, Object thisObj, Object[] return Math.sqrt(y); } - private static Object imul(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object imul( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args == null) { return 0; } @@ -442,33 +463,38 @@ private static Object imul(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.wrapNumber(x * y); } - private static Object log(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object log( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); // Java's log(<0) = -Infinity; we need NaN x = (x < 0) ? Double.NaN : Math.log(x); return ScriptRuntime.wrapNumber(x); } - private static Object log1p(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object log1p( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.log1p(x); return ScriptRuntime.wrapNumber(x); } - private static Object log10(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object log10( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.log10(x); return ScriptRuntime.wrapNumber(x); } - private static Object log2(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object log2( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); // Java's log(<0) = -Infinity; we need NaN x = (x < 0) ? Double.NaN : Math.log(x) * LOG2E; return ScriptRuntime.wrapNumber(x); } - private static Object max(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object max( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = Double.NEGATIVE_INFINITY; for (int i = 0; i != args.length; ++i) { double d = ScriptRuntime.toNumber(args[i]); @@ -478,7 +504,8 @@ private static Object max(Context cx, VarScope scope, Object thisObj, Object[] a return ScriptRuntime.wrapNumber(x); } - private static Object min(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object min( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = Double.POSITIVE_INFINITY; for (int i = 0; i != args.length; ++i) { double d = ScriptRuntime.toNumber(args[i]); @@ -489,7 +516,8 @@ private static Object min(Context cx, VarScope scope, Object thisObj, Object[] a } // See Ecma 15.8.2.13 - private static Object pow(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object pow( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); double y = ScriptRuntime.toNumber(args, 1); double result; @@ -545,11 +573,13 @@ private static Object pow(Context cx, VarScope scope, Object thisObj, Object[] a return ScriptRuntime.wrapNumber(result); } - private static Object random(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object random( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return ScriptRuntime.wrapNumber(Math.random()); } - private static Object round(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object round( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (!Double.isNaN(x) && !Double.isInfinite(x)) { // Round only finite x @@ -568,7 +598,8 @@ private static Object round(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.wrapNumber(x); } - private static Object sign(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object sign( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); if (!Double.isNaN(x)) { if (x == 0) { @@ -582,37 +613,43 @@ private static Object sign(Context cx, VarScope scope, Object thisObj, Object[] return ScriptRuntime.NaNobj; } - private static Object sin(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object sin( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Double.isInfinite(x) ? Double.NaN : Math.sin(x); return ScriptRuntime.wrapNumber(x); } - private static Object sinh(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object sinh( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.sinh(x); return ScriptRuntime.wrapNumber(x); } - private static Object sqrt(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object sqrt( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.sqrt(x); return ScriptRuntime.wrapNumber(x); } - private static Object tan(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object tan( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.tan(x); return ScriptRuntime.wrapNumber(x); } - private static Object tanh(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object tanh( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = Math.tanh(x); return ScriptRuntime.wrapNumber(x); } - private static Object trunc(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object trunc( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double x = ScriptRuntime.toNumber(args, 0); x = ((x < 0.0) ? Math.ceil(x) : Math.floor(x)); return ScriptRuntime.wrapNumber(x); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeNumber.java b/rhino/src/main/java/org/mozilla/javascript/NativeNumber.java index b5e4f3899d0..ffdf5edb0bb 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeNumber.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeNumber.java @@ -6,6 +6,11 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; +import static org.mozilla.javascript.ScriptRuntime.wrapNumber; + import java.text.NumberFormat; import java.util.IllformedLocaleException; import java.util.Locale; @@ -34,87 +39,57 @@ final class NativeNumber extends ScriptableObject { private static final double MIN_SAFE_INTEGER = -MAX_SAFE_INTEGER; private static final double EPSILON = 2.220446049250313e-16; - private final double doubleValue; + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 1, + NativeNumber::js_constructorFunc, + NativeNumber::js_constructor) + .withProp(CTOR, "NaN", value(ScriptRuntime.NaNobj)) + .withProp( + CTOR, + "POSITIVE_INFINITY", + value(wrapNumber(Double.POSITIVE_INFINITY))) + .withProp( + CTOR, + "NEGATIVE_INFINITY", + value(wrapNumber(Double.NEGATIVE_INFINITY))) + .withProp(CTOR, "MAX_VALUE", value(wrapNumber(Double.MAX_VALUE))) + .withProp(CTOR, "MIN_VALUE", value(wrapNumber(Double.MIN_VALUE))) + .withProp(CTOR, "MAX_SAFE_INTEGER", value(wrapNumber(MAX_SAFE_INTEGER))) + .withProp(CTOR, "MIN_SAFE_INTEGER", value(wrapNumber(MIN_SAFE_INTEGER))) + .withProp(CTOR, "EPSILON", value(wrapNumber(EPSILON))) + .withMethod(CTOR, "isFinite", 1, NativeNumber::js_isFinite) + .withMethod(CTOR, "isNaN", 1, NativeNumber::js_isNaN) + .withMethod(CTOR, "isInteger", 1, NativeNumber::js_isInteger) + .withMethod(CTOR, "isSafeInteger", 1, NativeNumber::js_isSafeInteger) + .withProp( + CTOR, + "parseFloat", + (c, s, o) -> + new DescriptorInfo(s.get("parseFloat", s), DONTENUM, true)) + .withProp( + CTOR, + "parseInt", + (c, s, o) -> + new DescriptorInfo(s.get("parseInt", s), DONTENUM, true)) + .withMethod(PROTO, "toString", 1, NativeNumber::js_toString) + .withMethod(PROTO, "toLocaleString", 0, NativeNumber::js_toLocaleString) + .withMethod(PROTO, "toSource", 0, NativeNumber::js_toSource) + .withMethod(PROTO, "valueOf", 0, NativeNumber::js_valueOf) + .withMethod(PROTO, "toFixed", 1, NativeNumber::js_toFixed) + .withMethod(PROTO, "toExponential", 1, NativeNumber::js_toExponential) + .withMethod(PROTO, "toPrecision", 1, NativeNumber::js_toPrecision) + .build(); + } - static void init(VarScope scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - CLASS_NAME, - 1, - NativeNumber::js_constructorFunc, - NativeNumber::js_constructor); - constructor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - constructor.setPrototypeScriptable(new NativeNumber(0.0)); - - final int propAttr = DONTENUM | PERMANENT | READONLY; - - constructor.defineProperty("NaN", ScriptRuntime.NaNobj, propAttr); - constructor.defineProperty( - "POSITIVE_INFINITY", ScriptRuntime.wrapNumber(Double.POSITIVE_INFINITY), propAttr); - constructor.defineProperty( - "NEGATIVE_INFINITY", ScriptRuntime.wrapNumber(Double.NEGATIVE_INFINITY), propAttr); - constructor.defineProperty( - "MAX_VALUE", ScriptRuntime.wrapNumber(Double.MAX_VALUE), propAttr); - constructor.defineProperty( - "MIN_VALUE", ScriptRuntime.wrapNumber(Double.MIN_VALUE), propAttr); - constructor.defineProperty( - "MAX_SAFE_INTEGER", ScriptRuntime.wrapNumber(MAX_SAFE_INTEGER), propAttr); - constructor.defineProperty( - "MIN_SAFE_INTEGER", ScriptRuntime.wrapNumber(MIN_SAFE_INTEGER), propAttr); - constructor.defineProperty("EPSILON", ScriptRuntime.wrapNumber(EPSILON), propAttr); - - constructor.defineConstructorMethod( - scope, - "isFinite", - 1, - null, - NativeNumber::js_isFinite, - DONTENUM, - DONTENUM | READONLY); - constructor.defineConstructorMethod( - scope, "isNaN", 1, null, NativeNumber::js_isNaN, DONTENUM, DONTENUM | READONLY); - constructor.defineConstructorMethod( - scope, - "isInteger", - 1, - null, - NativeNumber::js_isInteger, - DONTENUM, - DONTENUM | READONLY); - constructor.defineConstructorMethod( - scope, - "isSafeInteger", - 1, - null, - NativeNumber::js_isSafeInteger, - DONTENUM, - DONTENUM | READONLY); - - Object parseFloat = ScriptRuntime.getTopLevelProp(scope, "parseFloat"); - if (parseFloat instanceof Function) { - constructor.defineProperty("parseFloat", parseFloat, DONTENUM); - } - Object parseInt = ScriptRuntime.getTopLevelProp(scope, "parseInt"); - if (parseInt instanceof Function) { - constructor.defineProperty("parseInt", parseInt, DONTENUM); - } + private final double doubleValue; - constructor.definePrototypeMethod(scope, "toString", 1, NativeNumber::js_toString); - constructor.definePrototypeMethod( - scope, "toLocaleString", 0, NativeNumber::js_toLocaleString); - constructor.definePrototypeMethod(scope, "toSource", 0, NativeNumber::js_toSource); - constructor.definePrototypeMethod(scope, "valueOf", 0, NativeNumber::js_valueOf); - constructor.definePrototypeMethod(scope, "toFixed", 1, NativeNumber::js_toFixed); - constructor.definePrototypeMethod( - scope, "toExponential", 1, NativeNumber::js_toExponential); - constructor.definePrototypeMethod(scope, "toPrecision", 1, NativeNumber::js_toPrecision); - - ScriptableObject.defineProperty(scope, CLASS_NAME, constructor, DONTENUM); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } + static void init(Context cx, VarScope scope, boolean sealed) { + DESCRIPTOR.buildConstructor(cx, scope, new NativeNumber(0.0), sealed); } NativeNumber(double number) { @@ -126,21 +101,26 @@ public String getClassName() { return CLASS_NAME; } - private static Scriptable js_constructor(Context cx, VarScope scope, Object[] args) { + private static Scriptable js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double val = (args.length > 0) ? ScriptRuntime.toNumeric(args[0]).doubleValue() : 0.0; - return new NativeNumber(val); + var res = new NativeNumber(val); + ScriptRuntime.setBuiltinProtoAndParent(res, f, nt, s, TopLevel.Builtins.Number); + return res; } private static Object js_constructorFunc( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return (args.length > 0) ? ScriptRuntime.toNumeric(args[0]).doubleValue() : 0.0; } - private static Object js_valueOf(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_valueOf( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return toSelf(thisObj).doubleValue; } - private static Object js_toFixed(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toFixed( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double value = toSelf(thisObj).doubleValue; int fractionDigits; @@ -162,7 +142,7 @@ private static Object js_toFixed(Context cx, VarScope scope, Object thisObj, Obj } private static Object js_toExponential( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double value = toSelf(thisObj).doubleValue; double p; @@ -188,7 +168,7 @@ private static Object js_toExponential( } private static Object js_toPrecision( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { double value = toSelf(thisObj).doubleValue; // Undefined precision, fall back to ToString() if (args.length == 0 || Undefined.isUndefined(args[0])) { @@ -217,7 +197,8 @@ private static NativeNumber toSelf(Object thisObj) { return LambdaConstructor.convertThisObject(thisObj, NativeNumber.class); } - private static Object js_toString(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toString( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { int base = (args.length == 0 || Undefined.isUndefined(args[0])) ? 10 @@ -226,9 +207,9 @@ private static Object js_toString(Context cx, VarScope scope, Object thisObj, Ob } private static Object js_toLocaleString( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (!cx.hasFeature(Context.FEATURE_INTL_402)) { - return js_toString(cx, scope, thisObj, ScriptRuntime.emptyArgs); + return js_toString(cx, f, nt, s, thisObj, ScriptRuntime.emptyArgs); } if (args.length != 0 && args[0] instanceof String) { @@ -245,7 +226,7 @@ private static Object js_toLocaleString( } private static Object js_toSource( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return "(new Number(" + ScriptRuntime.toString(toSelf(thisObj).doubleValue) + "))"; } @@ -263,7 +244,8 @@ public String toString() { return ScriptRuntime.numberToString(doubleValue, 10); } - private static Object js_isFinite(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_isFinite( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Number n = argToNumber(args); return n == null ? Boolean.FALSE : isFinite(n); } @@ -273,7 +255,8 @@ static Object isFinite(Object val) { return Double.isFinite(nd); } - private static Object js_isNaN(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_isNaN( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Number val = argToNumber(args); if (val == null) { return false; @@ -285,7 +268,8 @@ private static Object js_isNaN(Context cx, VarScope scope, Object thisObj, Objec return Double.isNaN(d); } - private static Object js_isInteger(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_isInteger( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Number val = argToNumber(args); if (val == null) { return false; @@ -297,7 +281,7 @@ private static Object js_isInteger(Context cx, VarScope scope, Object thisObj, O } private static Object js_isSafeInteger( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Number val = argToNumber(args); if (val == null) { return false; diff --git a/rhino/src/main/java/org/mozilla/javascript/NativePromise.java b/rhino/src/main/java/org/mozilla/javascript/NativePromise.java index 368a733c758..e14f4c82fd0 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativePromise.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativePromise.java @@ -4,6 +4,10 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + import java.util.ArrayList; import org.mozilla.javascript.TopLevel.NativeErrors; @@ -20,6 +24,34 @@ enum ReactionType { REJECT } + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + "Promise", + 1, + ClassDescriptor.typeError(), + NativePromise::constructor) + .withMethod(CTOR, "resolve", 1, NativePromise::resolve) + .withMethod(CTOR, "reject", 1, NativePromise::reject) + .withMethod(CTOR, "all", 1, NativePromise::all) + .withMethod(CTOR, "allSettled", 1, NativePromise::allSettled) + .withMethod(CTOR, "race", 1, NativePromise::race) + .withMethod(CTOR, "any", 1, NativePromise::any) + .withMethod(CTOR, "withResolvers", 0, NativePromise::withResolvers) + .withMethod(CTOR, "try", 1, NativePromise::promiseTry) + .withMethod(PROTO, "then", 2, NativePromise::doThen) + .withMethod(PROTO, "catch", 1, NativePromise::doCatch) + .withMethod(PROTO, "finally", 1, NativePromise::doFinally) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value("Promise", DONTENUM | READONLY)) + .withProp(CTOR, SymbolKey.SPECIES, ScriptRuntimeES6::symbolSpecies) + .build(); + } + private State state = State.PENDING; private Object result = null; private boolean handled = false; @@ -28,49 +60,19 @@ enum ReactionType { private ArrayList rejectReactions = new ArrayList<>(); public static Object init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - "Promise", - 1, - LambdaConstructor.CONSTRUCTOR_NEW, - NativePromise::constructor); - constructor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - - constructor.defineConstructorMethod(scope, "resolve", 1, NativePromise::resolve); - constructor.defineConstructorMethod(scope, "reject", 1, NativePromise::reject); - constructor.defineConstructorMethod(scope, "all", 1, NativePromise::all); - constructor.defineConstructorMethod(scope, "allSettled", 1, NativePromise::allSettled); - constructor.defineConstructorMethod(scope, "race", 1, NativePromise::race); - constructor.defineConstructorMethod(scope, "any", 1, NativePromise::any); - constructor.defineConstructorMethod( - scope, "withResolvers", 0, NativePromise::withResolvers); - constructor.defineConstructorMethod(scope, "try", 1, NativePromise::promiseTry); - - ScriptRuntimeES6.addSymbolSpecies(cx, scope, constructor); - - constructor.definePrototypeMethod(scope, "then", 2, NativePromise::doThen); - constructor.definePrototypeMethod(scope, "catch", 1, NativePromise::doCatch); - constructor.definePrototypeMethod(scope, "finally", 1, NativePromise::doFinally); - - constructor.definePrototypeProperty( - SymbolKey.TO_STRING_TAG, "Promise", DONTENUM | READONLY); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } - return constructor; - } - - private static Scriptable constructor(Context cx, VarScope scope, Object[] args) { + return DESCRIPTOR.buildConstructor(cx, scope, new NativeObject(), sealed); + } + + private static Scriptable constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length < 1 || !(args[0] instanceof Callable)) { throw ScriptRuntime.typeErrorById("msg.function.expected"); } Callable executor = (Callable) args[0]; NativePromise promise = new NativePromise(); - ResolvingFunctions resolving = new ResolvingFunctions(scope, promise); + ResolvingFunctions resolving = new ResolvingFunctions(f.getDeclarationScope(), promise); - Scriptable thisObj = Undefined.SCRIPTABLE_UNDEFINED; + thisObj = Undefined.SCRIPTABLE_UNDEFINED; if (!cx.isStrictMode()) { TopLevel tcs = cx.topCallScope; if (tcs != null) { @@ -78,12 +80,16 @@ private static Scriptable constructor(Context cx, VarScope scope, Object[] args) } } + var thisArg = (Scriptable) thisObj; + try { - executor.call(cx, scope, thisObj, new Object[] {resolving.resolve, resolving.reject}); + executor.call(cx, s, thisArg, new Object[] {resolving.resolve, resolving.reject}); } catch (RhinoException re) { - resolving.reject.call(cx, scope, thisObj, new Object[] {getErrorObject(cx, scope, re)}); + resolving.reject.call( + cx, s, thisArg, new Object[] {getErrorObject(cx, f.getDeclarationScope(), re)}); } + ScriptRuntime.setBuiltinProtoAndParent(promise, f, nt, s, TopLevel.Builtins.Promise); return promise; } @@ -97,12 +103,13 @@ Object getResult() { } // Promise.resolve - private static Object resolve(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object resolve( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (!ScriptRuntime.isObject(thisObj)) { throw ScriptRuntime.typeErrorById("msg.arg.not.object", ScriptRuntime.typeof(thisObj)); } Object arg = (args.length > 0 ? args[0] : Undefined.instance); - return resolveInternal(cx, scope, thisObj, arg); + return resolveInternal(cx, s, thisObj, arg); } // PromiseResolve abstract operation @@ -120,18 +127,20 @@ private static Object resolveInternal( } // Promise.reject - private static Object reject(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object reject( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (!ScriptRuntime.isObject(thisObj)) { throw ScriptRuntime.typeErrorById("msg.arg.not.object", ScriptRuntime.typeof(thisObj)); } Object arg = (args.length > 0 ? args[0] : Undefined.instance); - Capability cap = new Capability(cx, scope, thisObj); - cap.reject.call(cx, scope, Undefined.SCRIPTABLE_UNDEFINED, new Object[] {arg}); + Capability cap = new Capability(cx, f.getDeclarationScope(), thisObj); + cap.reject.call( + cx, f.getDeclarationScope(), Undefined.SCRIPTABLE_UNDEFINED, new Object[] {arg}); return cap.promise; } private static Object doAll( - Context cx, VarScope scope, Scriptable thisObj, Object[] args, boolean failFast) { + Context cx, VarScope scope, Object thisObj, Object[] args, boolean failFast) { Capability cap = new Capability(cx, scope, thisObj); Object arg = (args.length > 0 ? args[0] : Undefined.instance); @@ -150,7 +159,8 @@ private static Object doAll( IteratorLikeIterable.Itr iterator = iterable.iterator(); try { - PromiseAllResolver resolver = new PromiseAllResolver(iterator, thisObj, cap, failFast); + PromiseAllResolver resolver = + new PromiseAllResolver(iterator, (Scriptable) thisObj, cap, failFast); try { return resolver.resolve(cx, scope); } finally { @@ -169,38 +179,41 @@ private static Object doAll( } // Promise.all - private static Object all(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { - return doAll(cx, scope, thisObj, args, true); + private static Object all( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return doAll(cx, f.getDeclarationScope(), thisObj, args, true); } // Promise.allSettled private static Object allSettled( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { - return doAll(cx, scope, thisObj, args, false); + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return doAll(cx, f.getDeclarationScope(), thisObj, args, false); } // Promise.race - private static Object race(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { - Capability cap = new Capability(cx, scope, thisObj); + private static Object race( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var fscope = f.getDeclarationScope(); + Capability cap = new Capability(cx, fscope, thisObj); Object arg = (args.length > 0 ? args[0] : Undefined.instance); IteratorLikeIterable iterable; try { - Object maybeIterable = ScriptRuntime.callIterator(arg, cx, scope); - iterable = new IteratorLikeIterable(cx, scope, maybeIterable); + Object maybeIterable = ScriptRuntime.callIterator(arg, cx, f.getDeclarationScope()); + iterable = new IteratorLikeIterable(cx, fscope, maybeIterable); } catch (RhinoException re) { cap.reject.call( cx, - scope, + fscope, Undefined.SCRIPTABLE_UNDEFINED, - new Object[] {getErrorObject(cx, scope, re)}); + new Object[] {getErrorObject(cx, fscope, re)}); return cap.promise; } IteratorLikeIterable.Itr iterator = iterable.iterator(); try { try { - return performRace(cx, scope, iterator, thisObj, cap); + return performRace(cx, fscope, iterator, thisObj, cap); } finally { if (!iterator.isDone()) { iterable.close(); @@ -209,9 +222,9 @@ private static Object race(Context cx, VarScope scope, Scriptable thisObj, Objec } catch (RhinoException re) { cap.reject.call( cx, - scope, + fscope, Undefined.SCRIPTABLE_UNDEFINED, - new Object[] {getErrorObject(cx, scope, re)}); + new Object[] {getErrorObject(cx, fscope, re)}); return cap.promise; } } @@ -220,7 +233,7 @@ private static Object performRace( Context cx, VarScope scope, IteratorLikeIterable.Itr iterator, - Scriptable thisObj, + Object thisObj, Capability cap) { var resolve = ScriptRuntime.getPropAndThis(thisObj, "resolve", cx, scope); @@ -255,28 +268,31 @@ private static Object performRace( } } - private static Object any(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { - Capability cap = new Capability(cx, scope, thisObj); + private static Object any( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var fscope = f.getDeclarationScope(); + Capability cap = new Capability(cx, fscope, thisObj); Object arg = (args.length > 0 ? args[0] : Undefined.instance); IteratorLikeIterable iterable; try { - Object maybeIterable = ScriptRuntime.callIterator(arg, cx, scope); - iterable = new IteratorLikeIterable(cx, scope, maybeIterable); + Object maybeIterable = ScriptRuntime.callIterator(arg, cx, fscope); + iterable = new IteratorLikeIterable(cx, fscope, maybeIterable); } catch (RhinoException re) { cap.reject.call( cx, - scope, + fscope, Undefined.SCRIPTABLE_UNDEFINED, - new Object[] {getErrorObject(cx, scope, re)}); + new Object[] {getErrorObject(cx, fscope, re)}); return cap.promise; } IteratorLikeIterable.Itr iterator = iterable.iterator(); try { - PromiseAnyRejector rejector = new PromiseAnyRejector(iterator, thisObj, cap); + PromiseAnyRejector rejector = + new PromiseAnyRejector(iterator, (Scriptable) thisObj, cap); try { - return rejector.reject(cx, scope); + return rejector.reject(cx, fscope); } finally { if (!iterator.isDone()) { iterable.close(); @@ -285,25 +301,26 @@ private static Object any(Context cx, VarScope scope, Scriptable thisObj, Object } catch (RhinoException re) { cap.reject.call( cx, - scope, + fscope, Undefined.SCRIPTABLE_UNDEFINED, - new Object[] {getErrorObject(cx, scope, re)}); + new Object[] {getErrorObject(cx, fscope, re)}); return cap.promise; } } // Promise.withResolvers private static Object withResolvers( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var fscope = f.getDeclarationScope(); if (!ScriptRuntime.isObject(thisObj)) { throw ScriptRuntime.typeErrorById("msg.arg.not.object", ScriptRuntime.typeof(thisObj)); } // Create a capability which properly constructs a promise with resolve/reject functions - Capability cap = new Capability(cx, scope, thisObj); + Capability cap = new Capability(cx, fscope, thisObj); // Create the result object with promise, resolve, and reject properties - Scriptable result = cx.newObject(scope); + Scriptable result = cx.newObject(fscope); result.put("promise", result, cap.promise); result.put("resolve", result, cap.resolve); result.put("reject", result, cap.reject); @@ -313,7 +330,8 @@ private static Object withResolvers( // Promise.try private static Object promiseTry( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var fscope = f.getDeclarationScope(); if (!ScriptRuntime.isObject(thisObj)) { throw ScriptRuntime.typeErrorById("msg.arg.not.object", ScriptRuntime.typeof(thisObj)); } @@ -325,7 +343,7 @@ private static Object promiseTry( Callable func = (Callable) args[0]; // Create a new promise capability using the constructor - Capability cap = new Capability(cx, scope, thisObj); + Capability cap = new Capability(cx, fscope, thisObj); // Prepare the arguments to pass to the function (all args after the function) Object[] funcArgs = new Object[args.length - 1]; @@ -333,17 +351,17 @@ private static Object promiseTry( try { // Call the function synchronously - Object result = func.call(cx, scope, Undefined.SCRIPTABLE_UNDEFINED, funcArgs); + Object result = func.call(cx, fscope, Undefined.SCRIPTABLE_UNDEFINED, funcArgs); // Resolve the promise with the result - cap.resolve.call(cx, scope, Undefined.SCRIPTABLE_UNDEFINED, new Object[] {result}); + cap.resolve.call(cx, fscope, Undefined.SCRIPTABLE_UNDEFINED, new Object[] {result}); } catch (RhinoException re) { // If the function throws, reject the promise with the error cap.reject.call( cx, - scope, + fscope, Undefined.SCRIPTABLE_UNDEFINED, - new Object[] {getErrorObject(cx, scope, re)}); + new Object[] {getErrorObject(cx, fscope, re)}); } return cap.promise; @@ -393,22 +411,27 @@ private void markHandled(Context cx) { } } - private static Object doThen(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object doThen( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativePromise self = LambdaConstructor.convertThisObject(thisObj, NativePromise.class); - return self.then(cx, scope, args); + return self.then(cx, f.getDeclarationScope(), args); } // Promise.prototype.catch - private static Object doCatch(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object doCatch( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var fscope = f.getDeclarationScope(); Object arg = (args.length > 0 ? args[0] : Undefined.instance); - Scriptable coercedThis = ScriptRuntime.toObject(cx, scope, thisObj); + Scriptable coercedThis = ScriptRuntime.toObject(cx, fscope, thisObj); // No guarantee that the caller didn't change the prototype of "then"! - var thenFunc = ScriptRuntime.getPropAndThis(coercedThis, "then", cx, scope); - return thenFunc.call(cx, scope, new Object[] {Undefined.instance, arg}); + var thenFunc = ScriptRuntime.getPropAndThis(coercedThis, "then", cx, fscope); + return thenFunc.call(cx, fscope, new Object[] {Undefined.instance, arg}); } // Promise.prototype.finally - private static Object doFinally(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + private static Object doFinally( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + var fscope = f.getDeclarationScope(); if (!ScriptRuntime.isObject(thisObj)) { throw ScriptRuntime.typeErrorById("msg.arg.not.object", ScriptRuntime.typeof(thisObj)); } @@ -417,16 +440,16 @@ private static Object doFinally(Context cx, VarScope scope, Scriptable thisObj, Object catchFinally = onFinally; var ctor = TopLevel.getBuiltinCtor( - cx, ScriptableObject.getTopLevelScope(scope), TopLevel.Builtins.Promise); + cx, ScriptableObject.getTopLevelScope(fscope), TopLevel.Builtins.Promise); Constructable constructor = - AbstractEcmaObjectOperations.speciesConstructor(cx, thisObj, ctor); + AbstractEcmaObjectOperations.speciesConstructor(cx, (Scriptable) thisObj, ctor); if (onFinally instanceof Callable) { Callable callableOnFinally = (Callable) thenFinally; - thenFinally = makeThenFinally(scope, constructor, callableOnFinally); - catchFinally = makeCatchFinally(scope, constructor, callableOnFinally); + thenFinally = makeThenFinally(fscope, constructor, callableOnFinally); + catchFinally = makeCatchFinally(fscope, constructor, callableOnFinally); } - var thenFunc = ScriptRuntime.getPropAndThis(thisObj, "then", cx, scope); - return thenFunc.call(cx, scope, new Object[] {thenFinally, catchFinally}); + var thenFunc = ScriptRuntime.getPropAndThis(thisObj, "then", cx, fscope); + return thenFunc.call(cx, fscope, new Object[] {thenFinally, catchFinally}); } // Abstract "Then Finally Function" @@ -435,13 +458,13 @@ private static Callable makeThenFinally( return new LambdaFunction( scope, 1, - (Context cx, VarScope ls, Scriptable thisObj, Object[] args) -> { + (Context cx, VarScope ls, Object thisObj, Object[] args) -> { Object value = args.length > 0 ? args[0] : Undefined.instance; LambdaFunction valueThunk = new LambdaFunction( scope, 0, - (Context vc, VarScope vs, Scriptable vt, Object[] va) -> value); + (Context vc, VarScope vs, Object vt, Object[] va) -> value); Object result = onFinally.call( cx, @@ -460,13 +483,13 @@ private static Callable makeCatchFinally( return new LambdaFunction( scope, 1, - (Context cx, VarScope ls, Scriptable thisObj, Object[] args) -> { + (Context cx, VarScope ls, Object thisObj, Object[] args) -> { Object reason = args.length > 0 ? args[0] : Undefined.instance; LambdaFunction reasonThrower = new LambdaFunction( scope, 0, - (Context vc, VarScope vs, Scriptable vt, Object[] va) -> { + (Context vc, VarScope vs, Object vt, Object[] va) -> { throw new JavaScriptException(reason, null, 0); }); Object result = @@ -576,6 +599,95 @@ private static Object getErrorObject(Context cx, VarScope scope, RhinoException return ScriptRuntime.newNativeError(cx, scope, constructor, new Object[] {re.getMessage()}); } + // Async function support: create a Promise that drives an ES6Generator + // This implements the "async function" semantics: await expr = yield expr internally, + // with the Promise runner stepping through the generator via .then() reactions. + public static Object createAsyncFunctionPromise(Context cx, VarScope scope, ES6Generator gen) { + VarScope topScope = ScriptableObject.getTopLevelScope(scope); + Object promiseCtor = TopLevel.getBuiltinCtor(cx, topScope, TopLevel.Builtins.Promise); + Capability cap = new Capability(cx, scope, promiseCtor); + asyncStep(cx, scope, gen, cap, Undefined.instance, false); + return cap.promise; + } + + private static void asyncStep( + Context cx, + VarScope scope, + ES6Generator gen, + Capability cap, + Object value, + boolean isThrow) { + // Generator resumption requires cx.topCallScope to be set. When called + // from a microtask (after doTopCall has returned), it will be null. + boolean needTopCall = !ScriptRuntime.hasTopCall(cx); + if (needTopCall) { + cx.topCallScope = ScriptableObject.getTopLevelScope(scope); + cx.useDynamicScope = cx.hasFeature(Context.FEATURE_DYNAMIC_SCOPE); + } + try { + Scriptable result; + try { + if (isThrow) { + result = + gen.resumeAbruptLocal( + cx, scope, NativeGenerator.GENERATOR_THROW, value); + } else { + result = gen.resumeLocal(cx, scope, value); + } + } catch (JavaScriptException jse) { + cap.reject.call( + cx, scope, Undefined.SCRIPTABLE_UNDEFINED, new Object[] {jse.getValue()}); + return; + } catch (RhinoException re) { + cap.reject.call( + cx, + scope, + Undefined.SCRIPTABLE_UNDEFINED, + new Object[] {getErrorObject(cx, scope, re)}); + return; + } + boolean done = + Boolean.TRUE.equals( + ScriptableObject.getProperty(result, ES6Iterator.DONE_PROPERTY)); + Object nextValue = ScriptableObject.getProperty(result, ES6Iterator.VALUE_PROPERTY); + if (done) { + cap.resolve.call( + cx, scope, Undefined.SCRIPTABLE_UNDEFINED, new Object[] {nextValue}); + } else { + VarScope topScope = ScriptableObject.getTopLevelScope(scope); + Object promiseCtor = + TopLevel.getBuiltinCtor(cx, topScope, TopLevel.Builtins.Promise); + NativePromise nextPromise = + (NativePromise) resolveInternal(cx, scope, promiseCtor, nextValue); + nextPromise.then( + cx, + scope, + new Object[] { + new LambdaFunction( + scope, + 1, + (cx2, s, thisObj, args) -> { + Object v = args.length > 0 ? args[0] : Undefined.instance; + asyncStep(cx2, s, gen, cap, v, false); + return Undefined.instance; + }), + new LambdaFunction( + scope, + 1, + (cx2, s, thisObj, args) -> { + Object r = args.length > 0 ? args[0] : Undefined.instance; + asyncStep(cx2, s, gen, cap, r, true); + return Undefined.instance; + }) + }); + } + } finally { + if (needTopCall) { + cx.topCallScope = null; + } + } + } + // Output of "CreateResolvingFunctions." Carries with it an "alreadyResolved" state, // so we make it a separate object. This actually fires resolution functions on // the passed callbacks. @@ -590,7 +702,7 @@ private static class ResolvingFunctions { new LambdaFunction( topScope, 1, - (Context cx, VarScope scope, Scriptable thisObj, Object[] args) -> + (Context cx, VarScope scope, Object thisObj, Object[] args) -> resolve( cx, scope, @@ -600,7 +712,7 @@ private static class ResolvingFunctions { new LambdaFunction( topScope, 1, - (Context cx, VarScope scope, Scriptable thisObj, Object[] args) -> + (Context cx, VarScope scope, Object thisObj, Object[] args) -> reject( cx, scope, @@ -714,7 +826,7 @@ private static class Capability { new LambdaFunction( topScope, 2, - (Context cx, VarScope scope, Scriptable thisObj, Object[] args) -> + (Context cx, VarScope scope, Object thisObj, Object[] args) -> executor(args)); promise = ((Constructable) pc).construct(topCx, topScope, new Object[] {executorFunc}); @@ -753,15 +865,12 @@ private static class PromiseAllResolver { int remainingElements = 1; IteratorLikeIterable.Itr iterator; - Scriptable thisObj; + Object thisObj; Capability capability; boolean failFast; PromiseAllResolver( - IteratorLikeIterable.Itr iter, - Scriptable thisObj, - Capability cap, - boolean failFast) { + IteratorLikeIterable.Itr iter, Object thisObj, Capability cap, boolean failFast) { this.iterator = iter; this.thisObj = thisObj; this.capability = cap; @@ -812,7 +921,7 @@ Object resolve(Context topCx, VarScope topScope) { new LambdaFunction( topScope, 1, - (Context cx, VarScope scope, Scriptable thisObj, Object[] args) -> { + (cx, scope, thisObj, args) -> { Object value = (args.length > 0 ? args[0] : Undefined.instance); if (!failFast) { Scriptable elementResult = cx.newObject(scope); @@ -829,10 +938,7 @@ Object resolve(Context topCx, VarScope topScope) { new LambdaFunction( topScope, 1, - (Context cx, - VarScope scope, - Scriptable thisObj, - Object[] args) -> { + (cx, scope, thisObj, args) -> { Scriptable result = cx.newObject(scope); result.put("status", result, " rejected"); result.put( @@ -929,7 +1035,7 @@ Object reject(Context topCx, VarScope topScope) { new LambdaFunction( topScope, 1, - (Context cx, VarScope scope, Scriptable thisObj, Object[] args) -> { + (cx, scope, thisObj, args) -> { Object value = (args.length > 0 ? args[0] : Undefined.instance); return eltResolver.reject(cx, scope, value, this); }); diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeProxy.java b/rhino/src/main/java/org/mozilla/javascript/NativeProxy.java index 060b0199f17..7b57c243f68 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeProxy.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeProxy.java @@ -6,6 +6,8 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; + import java.util.ArrayList; import java.util.HashSet; import java.util.List; @@ -35,6 +37,19 @@ class NativeProxy extends ScriptableObject { private static final String TRAP_APPLY = "apply"; private static final String TRAP_CONSTRUCT = "construct"; + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + PROXY_TAG, + 2, + ClassDescriptor.typeError(), + NativeProxy::js_constructor) + .withMethod(CTOR, "revocable", 2, NativeProxy::revocable) + .build(); + } + private ScriptableObject targetObj; private Scriptable handlerObj; private final String typeOf; @@ -47,7 +62,7 @@ public Revoker(NativeProxy proxy) { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { if (revocableProxy != null) { revocableProxy.handlerObj = null; revocableProxy.targetObj = null; @@ -58,31 +73,7 @@ public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args } public static Object init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - PROXY_TAG, - 2, - null, // Proxy constructor has *no* prototype - null, // Proxy constructor may not be called as a function. - NativeProxy::constructor) { - - @Override - public Scriptable construct(Context cx, VarScope scope, Object[] args) { - NativeProxy obj = - (NativeProxy) getTargetConstructor().construct(cx, scope, args); - // avoid getting trapped - obj.setPrototypeDirect(getClassPrototype()); - obj.setParentScope(scope); - return obj; - } - }; - - constructor.defineConstructorMethod(scope, "revocable", 2, NativeProxy::revocable); - if (sealed) { - constructor.sealObject(); - } - return constructor; + return DESCRIPTOR.buildConstructor(cx, scope, null, sealed); } private NativeProxy(ScriptableObject target, Scriptable handler) { @@ -1224,7 +1215,8 @@ public void setPrototype(Scriptable prototype) { target.setPrototype(prototype); } - private static NativeProxy constructor(Context cx, VarScope scope, Object[] args) { + private static NativeProxy js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length < 2) { throw ScriptRuntime.typeErrorById( "msg.method.missing.parameter", @@ -1242,22 +1234,25 @@ private static NativeProxy constructor(Context cx, VarScope scope, Object[] args proxy = new NativeProxy(target, handler); } - proxy.setPrototypeDirect(ScriptableObject.getClassPrototype(scope, PROXY_TAG)); - proxy.setParentScope(scope); + // Can't use the normal function here as we `setPrototype()` would call the trap. + proxy.setPrototypeDirect(ScriptRuntime.findPrototype(f, nt, TopLevel.Builtins.Proxy)); + proxy.setParentScope(s); + return proxy; } // Proxy.revocable - private static Object revocable(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object revocable( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (!ScriptRuntime.isObject(thisObj)) { throw ScriptRuntime.typeErrorById("msg.arg.not.object", ScriptRuntime.typeof(thisObj)); } - NativeProxy proxy = constructor(cx, scope, args); + NativeProxy proxy = js_constructor(cx, f, nt, s, thisObj, args); - NativeObject revocable = (NativeObject) cx.newObject(scope); + NativeObject revocable = (NativeObject) cx.newObject(s); revocable.put("proxy", revocable, proxy); - revocable.put("revoke", revocable, new LambdaFunction(scope, "", 0, new Revoker(proxy))); + revocable.put("revoke", revocable, new LambdaFunction(s, "", 0, new Revoker(proxy))); return revocable; } @@ -1328,13 +1323,44 @@ public Scriptable construct(Context cx, VarScope scope, Object[] args) { return ((Constructable) target).construct(cx, scope, args); } + @Override + public Scriptable construct( + Context cx, Object nt, VarScope s, Object thisObj, Object[] args) { + /* + * 1. Let handler be O.[[ProxyHandler]]. + * 2. If handler is null, throw a TypeError exception. + * 3. Assert: Type(handler) is Object. + * 4. Let target be O.[[ProxyTarget]]. + * 5. Assert: IsConstructor(target) is true. + * 6. Let trap be ? GetMethod(handler, "construct"). + * 7. If trap is undefined, then + * a. Return ? Construct(target, argumentsList, newTarget). + * 8. Let argArray be ! CreateArrayFromList(argumentsList). + * 9. Let newObj be ? Call(trap, handler, « target, argArray, newTarget »). + * 10. If Type(newObj) is not Object, throw a TypeError exception. + * 11. Return newObj. + */ + ScriptableObject target = getTargetThrowIfRevoked(); + + Function trap = getTrap(TRAP_CONSTRUCT); + if (trap != null) { + Object result = callTrap(trap, new Object[] {target, args, this}); + if (!(result instanceof Scriptable) || ScriptRuntime.isSymbol(result)) { + throw ScriptRuntime.typeError("Constructor trap has to return a scriptable."); + } + return (ScriptableObject) result; + } + + return ((Constructable) target).construct(cx, nt, s, thisObj, args); + } + /** * see 10.5.12 * [[Call]] (thisArgument, argumentsList) */ @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { /* * 1. Let handler be O.[[ProxyHandler]]. * 2. If handler is null, throw a TypeError exception. diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeReflect.java b/rhino/src/main/java/org/mozilla/javascript/NativeReflect.java index 006596e3336..64fb4b5c02c 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeReflect.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeReflect.java @@ -6,6 +6,9 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; + import java.util.ArrayList; import java.util.List; import org.mozilla.javascript.ScriptRuntime.StringIdOrIndex; @@ -20,32 +23,37 @@ final class NativeReflect extends ScriptableObject { private static final String REFLECT_TAG = "Reflect"; + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder(REFLECT_TAG) + .withMethod(CTOR, "apply", 3, NativeReflect::apply) + .withMethod(CTOR, "construct", 2, NativeReflect::construct) + .withMethod(CTOR, "defineProperty", 3, NativeReflect::defineProperty) + .withMethod(CTOR, "deleteProperty", 2, NativeReflect::deleteProperty) + .withMethod(CTOR, "get", 2, NativeReflect::get) + .withMethod( + CTOR, + "getOwnPropertyDescriptor", + 2, + NativeReflect::getOwnPropertyDescriptor) + .withMethod(CTOR, "getPrototypeOf", 1, NativeReflect::getPrototypeOf) + .withMethod(CTOR, "has", 2, NativeReflect::has) + .withMethod(CTOR, "isExtensible", 1, NativeReflect::isExtensible) + .withMethod(CTOR, "ownKeys", 1, NativeReflect::ownKeys) + .withMethod(CTOR, "preventExtensions", 1, NativeReflect::preventExtensions) + .withMethod(CTOR, "set", 3, NativeReflect::set) + .withMethod(CTOR, "setPrototypeOf", 2, NativeReflect::setPrototypeOf) + .withProp( + CTOR, + SymbolKey.TO_STRING_TAG, + value(REFLECT_TAG, DONTENUM | READONLY)) + .build(); + } + public static Object init(Context cx, VarScope scope, boolean sealed) { - NativeReflect reflect = new NativeReflect(); - reflect.setPrototype(getObjectPrototype(scope)); - reflect.setParentScope(scope); - - reflect.defineBuiltinProperty(scope, "apply", 3, NativeReflect::apply); - reflect.defineBuiltinProperty(scope, "construct", 2, NativeReflect::construct); - reflect.defineBuiltinProperty(scope, "defineProperty", 3, NativeReflect::defineProperty); - reflect.defineBuiltinProperty(scope, "deleteProperty", 2, NativeReflect::deleteProperty); - reflect.defineBuiltinProperty(scope, "get", 2, NativeReflect::get); - reflect.defineBuiltinProperty( - scope, "getOwnPropertyDescriptor", 2, NativeReflect::getOwnPropertyDescriptor); - reflect.defineBuiltinProperty(scope, "getPrototypeOf", 1, NativeReflect::getPrototypeOf); - reflect.defineBuiltinProperty(scope, "has", 2, NativeReflect::has); - reflect.defineBuiltinProperty(scope, "isExtensible", 1, NativeReflect::isExtensible); - reflect.defineBuiltinProperty(scope, "ownKeys", 1, NativeReflect::ownKeys); - reflect.defineBuiltinProperty( - scope, "preventExtensions", 1, NativeReflect::preventExtensions); - reflect.defineBuiltinProperty(scope, "set", 3, NativeReflect::set); - reflect.defineBuiltinProperty(scope, "setPrototypeOf", 2, NativeReflect::setPrototypeOf); - - reflect.defineProperty(SymbolKey.TO_STRING_TAG, REFLECT_TAG, DONTENUM | READONLY); - if (sealed) { - reflect.sealObject(); - } - return reflect; + return DESCRIPTOR.populateGlobal(cx, scope, new NativeObject(), sealed); } private NativeReflect() {} @@ -55,7 +63,8 @@ public String getClassName() { return "Reflect"; } - private static Object apply(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object apply( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length < 3) { throw ScriptRuntime.typeErrorById( "msg.method.missing.parameter", @@ -69,7 +78,7 @@ private static Object apply(Context cx, VarScope scope, Object thisObj, Object[] if (args[1] instanceof Scriptable) { thisObj = (Scriptable) args[1]; } else if (ScriptRuntime.isPrimitive(args[1])) { - thisObj = cx.newObject(scope, "Object", new Object[] {args[1]}); + thisObj = cx.newObject(s, "Object", new Object[] {args[1]}); } if (ScriptRuntime.isSymbol(args[2])) { @@ -78,7 +87,7 @@ private static Object apply(Context cx, VarScope scope, Object thisObj, Object[] ScriptableObject argumentsList = ScriptableObject.ensureScriptableObject(args[2]); return ScriptRuntime.applyOrCall( - true, cx, scope, callable, new Object[] {thisObj, argumentsList}); + true, cx, s, callable, new Object[] {thisObj, argumentsList}); } /** @@ -86,7 +95,7 @@ private static Object apply(Context cx, VarScope scope, Object thisObj, Object[] * Reflect.construct (target, argumentsList[, newTarget]) */ private static Scriptable construct( - Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { /* * 1. If IsConstructor(target) is false, throw a TypeError exception. * 2. If newTarget is not present, set newTarget to target. @@ -106,62 +115,27 @@ private static Scriptable construct( throw ScriptRuntime.typeErrorById("msg.not.ctor", ScriptRuntime.typeof(args[0])); } - Constructable ctor = (Constructable) args[0]; + Constructable target = (Constructable) args[0]; if (args.length < 2) { - return ctor.construct(cx, scope, ScriptRuntime.emptyArgs); - } - - if (args.length > 2 && !AbstractEcmaObjectOperations.isConstructor(cx, args[2])) { - throw ScriptRuntime.typeErrorById("msg.not.ctor", ScriptRuntime.typeof(args[2])); + return target.construct(cx, target, s, null, ScriptRuntime.emptyArgs); } Object[] callArgs = ScriptRuntime.getApplyArguments(cx, args[1]); - Object newTargetPrototype = null; - if (args.length > 2) { - Scriptable newTarget = ScriptableObject.ensureScriptable(args[2]); - - if (newTarget instanceof BaseFunction) { - newTargetPrototype = ((BaseFunction) newTarget).getPrototypeProperty(); - } else { - newTargetPrototype = newTarget.get("prototype", newTarget); - } - - if (!(newTargetPrototype instanceof Scriptable) - || ScriptRuntime.isSymbol(newTargetPrototype) - || Undefined.isUndefined(newTargetPrototype)) { - newTargetPrototype = null; - } - } - - // our Constructable interface does not support the newTarget; - // therefore we use a cloned implementation that fixes - // the prototype before executing call(..). - if (ctor instanceof BaseFunction && newTargetPrototype != null) { - BaseFunction ctorBaseFunction = (BaseFunction) ctor; - Scriptable result = ctorBaseFunction.createObject(cx, scope); - if (result != null) { - result.setPrototype((Scriptable) newTargetPrototype); - - Object val = ctorBaseFunction.call(cx, scope, result, callArgs); - if (val instanceof Scriptable) { - return (Scriptable) val; - } - - return result; - } - } - - Scriptable newScriptable = ctor.construct(cx, scope, callArgs); - if (newTargetPrototype != null) { - newScriptable.setPrototype((Scriptable) newTargetPrototype); + Constructable newTarget; + if (args.length < 3) { + newTarget = target; + } else if (AbstractEcmaObjectOperations.isConstructor(cx, args[2])) { + newTarget = (Function) args[2]; + } else { + throw ScriptRuntime.typeErrorById("msg.not.ctor", ScriptRuntime.typeof(args[2])); } - return newScriptable; + return target.construct(cx, newTarget, s, null, callArgs); } private static Object defineProperty( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length < 3) { throw ScriptRuntime.typeErrorById( "msg.method.missing.parameter", @@ -191,7 +165,7 @@ private static Object defineProperty( } private static Object deleteProperty( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); if (args.length > 1) { @@ -204,7 +178,8 @@ private static Object deleteProperty( return false; } - private static Object get(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object get( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); if (args.length > 1) { @@ -224,29 +199,30 @@ private static Object get(Context cx, VarScope scope, Object thisObj, Object[] a } private static Scriptable getOwnPropertyDescriptor( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); if (args.length > 1) { if (ScriptRuntime.isSymbol(args[1])) { var desc = target.getOwnPropertyDescriptor(cx, args[1]); - return desc == null ? Undefined.SCRIPTABLE_UNDEFINED : desc.toObject(scope); + return desc == null ? Undefined.SCRIPTABLE_UNDEFINED : desc.toObject(s); } var desc = target.getOwnPropertyDescriptor(cx, ScriptRuntime.toString(args[1])); - return desc == null ? Undefined.SCRIPTABLE_UNDEFINED : desc.toObject(scope); + return desc == null ? Undefined.SCRIPTABLE_UNDEFINED : desc.toObject(s); } return Undefined.SCRIPTABLE_UNDEFINED; } private static Scriptable getPrototypeOf( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); return target.getPrototype(); } - private static Object has(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object has( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); if (args.length > 1) { @@ -259,12 +235,14 @@ private static Object has(Context cx, VarScope scope, Object thisObj, Object[] a return false; } - private static Object isExtensible(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object isExtensible( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); return target.isExtensible(); } - private static Scriptable ownKeys(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Scriptable ownKeys( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); final List strings = new ArrayList<>(); @@ -286,17 +264,18 @@ private static Scriptable ownKeys(Context cx, VarScope scope, Object thisObj, Ob System.arraycopy(strings.toArray(), 0, keys, 0, strings.size()); System.arraycopy(symbols.toArray(), 0, keys, strings.size(), symbols.size()); - return cx.newArray(scope, keys); + return cx.newArray(s, keys); } private static Object preventExtensions( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); return target.preventExtensions(); } - private static Object set(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object set( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { ScriptableObject target = checkTarget(args); if (args.length < 2) { return true; @@ -309,7 +288,7 @@ private static Object set(Context cx, VarScope scope, Object thisObj, Object[] a if (descriptor != null) { Object setter = descriptor.setter; if (setter != null && setter != NOT_FOUND) { - ((Function) setter).call(cx, scope, receiver, new Object[] {args[2]}); + ((Function) setter).call(cx, s, receiver, new Object[] {args[2]}); return true; } @@ -322,11 +301,11 @@ private static Object set(Context cx, VarScope scope, Object thisObj, Object[] a if (ScriptRuntime.isSymbol(args[1])) { receiver.put((Symbol) args[1], receiver, args[2]); } else { - StringIdOrIndex s = ScriptRuntime.toStringIdOrIndex(args[1]); - if (s.stringId == null) { - receiver.put(s.index, receiver, args[2]); + StringIdOrIndex soi = ScriptRuntime.toStringIdOrIndex(args[1]); + if (soi.stringId == null) { + receiver.put(soi.index, receiver, args[2]); } else { - receiver.put(s.stringId, receiver, args[2]); + receiver.put(soi.stringId, receiver, args[2]); } } @@ -334,7 +313,7 @@ private static Object set(Context cx, VarScope scope, Object thisObj, Object[] a } private static Object setPrototypeOf( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length < 2) { throw ScriptRuntime.typeErrorById( "msg.method.missing.parameter", diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeScript.java b/rhino/src/main/java/org/mozilla/javascript/NativeScript.java index bf528b1282b..7e5331b51f5 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeScript.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeScript.java @@ -6,6 +6,8 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + import java.util.EnumSet; /** @@ -23,46 +25,26 @@ class NativeScript extends BaseFunction { private static final long serialVersionUID = -6795101161980121700L; - private static final Object SCRIPT_TAG = "Script"; - - static LambdaConstructor init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor obj = - new LambdaConstructor( - scope, - "Script", - 1, - NativeScript::js_constructorCall, - NativeScript::js_constructor); - - var proto = new NativeScript(null); - proto.setPrototypeProperty(null); - obj.setPrototypeProperty(proto); - - var function = (Scriptable) ScriptableObject.getProperty(scope, "Function"); - var functionProto = (Scriptable) ScriptableObject.getProperty(function, "prototype"); - proto.setPrototype(functionProto); - - defineMethod(obj, scope, "toString", 0, NativeScript::js_toString); - defineMethod(obj, scope, "exec", 0, NativeScript::js_exec); - defineMethod(obj, scope, "compile", 0, NativeScript::js_compile); + private static final String SCRIPT_TAG = "Script"; - ScriptableObject.defineProperty(scope, "Script", obj, DONTENUM); - if (sealed) { - obj.sealObject(); - ((ScriptableObject) obj.getPrototypeProperty()).sealObject(); - } + private static final ClassDescriptor DESCRIPTOR; - return obj; + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + SCRIPT_TAG, + 1, + NativeScript::js_constructorCall, + NativeScript::js_constructor) + .withMethod(PROTO, "toString", 0, NativeScript::js_toString) + .withMethod(PROTO, "exec", 0, NativeScript::js_exec) + .withMethod(PROTO, "compile", 0, NativeScript::js_compile) + .build(); } - private static void defineMethod( - LambdaConstructor typedArray, - VarScope scope, - String name, - int length, - SerializableCallable target) { - typedArray.definePrototypeMethod( - scope, name, length, target, DONTENUM, DONTENUM | READONLY); + static JSFunction init2(Context cx, VarScope scope, boolean sealed) { + var proto = new NativeScript(null); + return DESCRIPTOR.buildConstructor(cx, scope, proto, sealed); } /** @@ -70,10 +52,11 @@ private static void defineMethod( */ @Deprecated static void init(VarScope scope, boolean sealed) { - init(Context.getContext(), scope, sealed); + init2(Context.getContext(), scope, sealed); } private NativeScript(Script script) { + super(null); this.script = script; } @@ -84,7 +67,7 @@ public String getClassName() { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { if (script != null) { return script.exec(cx, scope, thisObj); } @@ -114,18 +97,21 @@ String decompile(int indent, EnumSet flags) { return super.decompile(indent, flags); } - private static Object js_compile(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_compile( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeScript real = realThis(thisObj, "compile"); String source = ScriptRuntime.toString(args, 0); real.script = compile(cx, source); return real; } - private static Object js_exec(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_exec( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { throw Context.reportRuntimeErrorById("msg.cant.call.indirect", "exec"); } - private static Object js_toString(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toString( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeScript real = realThis(thisObj, "toString"); Script realScript = real.script; if (realScript == null) { @@ -135,15 +121,16 @@ private static Object js_toString(Context cx, VarScope scope, Object thisObj, Ob } private static Scriptable js_constructorCall( - Context cx, VarScope scope, Object thisObj, Object[] args) { - return js_constructor(cx, scope, args); + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return js_constructor(cx, f, nt, s, thisObj, args); } - private static Scriptable js_constructor(Context cx, VarScope scope, Object[] args) { + private static Scriptable js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String source = (args.length == 0) ? "" : ScriptRuntime.toString(args[0]); Script script = compile(cx, source); NativeScript nscript = new NativeScript(script); - ScriptRuntime.setObjectProtoAndParent(nscript, scope); + ScriptRuntime.setObjectProtoAndParent(nscript, f.getDeclarationScope()); return nscript; } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeSet.java b/rhino/src/main/java/org/mozilla/javascript/NativeSet.java index 1fa7ca0db51..cdcb8e60933 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeSet.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeSet.java @@ -6,6 +6,11 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.alias; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + public class NativeSet extends ScriptableObject { private static final long serialVersionUID = -8442212766987072986L; private static final String CLASS_NAME = "Set"; @@ -13,80 +18,69 @@ public class NativeSet extends ScriptableObject { static final SymbolKey GETSIZE = new SymbolKey("[Symbol.getSize]", Symbol.Kind.REGULAR); + private static final ClassDescriptor DESCRIPTOR; + private static final ClassDescriptor ITER_DESCRIPTOR = + ES6Iterator.makeDescriptor(ITERATOR_TAG, ITERATOR_TAG); + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 0, + ClassDescriptor.typeError(), + NativeSet::js_constructor) + .withMethod(PROTO, "add", 1, NativeSet::js_add) + .withMethod(PROTO, "delete", 1, NativeSet::js_delete) + .withMethod(PROTO, "has", 1, NativeSet::js_has) + .withMethod(PROTO, "clear", 0, NativeSet::js_clear) + .withMethod(PROTO, "values", 0, NativeSet::js_values) + .withProp(PROTO, "keys", alias("values", DONTENUM | READONLY)) + .withProp(PROTO, SymbolKey.ITERATOR, alias("values", DONTENUM)) + .withMethod(PROTO, "forEach", 1, NativeSet::js_forEach) + .withMethod(PROTO, "entries", 0, NativeSet::js_entries) + + // ES2025 Set methods + .withMethod(PROTO, "intersection", 1, NativeSet::js_intersection) + .withMethod(PROTO, "union", 1, NativeSet::js_union) + .withMethod(PROTO, "difference", 1, NativeSet::js_difference) + .withMethod( + PROTO, "symmetricDifference", 1, NativeSet::js_symmetricDifference) + .withMethod(PROTO, "isSubsetOf", 1, NativeSet::js_isSubsetOf) + .withMethod(PROTO, "isSupersetOf", 1, NativeSet::js_isSupersetOf) + .withMethod(PROTO, "isDisjointFrom", 1, NativeSet::js_isDisjointFrom) + .withProp( + PROTO, + "size", + (thisObj) -> realThis(thisObj, "size").js_getSize(), + null, + DONTENUM) + .withProp( + PROTO, + NativeSet.GETSIZE, + (thisObj) -> realThis(thisObj, "size").js_getSize(), + null, + DONTENUM | PERMANENT) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value(CLASS_NAME, DONTENUM | READONLY)) + .withProp(CTOR, SymbolKey.SPECIES, ScriptRuntimeES6::symbolSpecies) + .build(); + } + private final Hashtable entries = new Hashtable(); private boolean instanceOfSet = false; - static Object init(Context cx, VarScope s, boolean sealed) { - TopLevel scope = (TopLevel) s; - LambdaConstructor constructor = - new LambdaConstructor( - scope, - CLASS_NAME, - 0, - LambdaConstructor.CONSTRUCTOR_NEW, - NativeSet::jsConstructor); - constructor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - - var propAttrs = DONTENUM | READONLY; - constructor.definePrototypeMethod(scope, "add", 1, NativeSet::js_add, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, "delete", 1, NativeSet::js_delete, DONTENUM, propAttrs); - constructor.definePrototypeMethod(scope, "has", 1, NativeSet::js_has, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, "clear", 0, NativeSet::js_clear, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, "values", 0, NativeSet::js_values, DONTENUM, propAttrs); - constructor.definePrototypeAlias("values", "keys", propAttrs); - constructor.definePrototypeAlias("values", SymbolKey.ITERATOR, DONTENUM); - - constructor.definePrototypeMethod( - scope, "forEach", 1, NativeSet::js_forEach, DONTENUM, propAttrs); - - constructor.definePrototypeMethod( - scope, "entries", 0, NativeSet::js_entries, DONTENUM, propAttrs); - - // ES2025 Set methods - constructor.definePrototypeMethod( - scope, "intersection", 1, NativeSet::js_intersection, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, "union", 1, NativeSet::js_union, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, "difference", 1, NativeSet::js_difference, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, - "symmetricDifference", - 1, - NativeSet::js_symmetricDifference, - DONTENUM, - propAttrs); - constructor.definePrototypeMethod( - scope, "isSubsetOf", 1, NativeSet::js_isSubsetOf, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, "isSupersetOf", 1, NativeSet::js_isSupersetOf, DONTENUM, propAttrs); - constructor.definePrototypeMethod( - scope, "isDisjointFrom", 1, NativeSet::js_isDisjointFrom, DONTENUM, propAttrs); - - // The spec requires very specific handling of the "size" prototype - // property that's not like other things that we already do. - ScriptableObject desc = (ScriptableObject) cx.newObject(scope); - desc.put("enumerable", desc, Boolean.FALSE); - desc.put("configurable", desc, Boolean.TRUE); - LambdaFunction sizeFunc = new LambdaFunction(scope, "get size", 0, NativeSet::js_getSize); - sizeFunc.setPrototypeProperty(Undefined.instance); - desc.put("get", desc, sizeFunc); - constructor.definePrototypeProperty(cx, "size", desc); - constructor.definePrototypeProperty(cx, NativeSet.GETSIZE, desc); - - constructor.definePrototypeProperty( - SymbolKey.TO_STRING_TAG, CLASS_NAME, DONTENUM | READONLY); - - ScriptRuntimeES6.addSymbolSpecies(cx, scope, constructor); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } - return constructor; + static Object init(Context cx, VarScope scope, boolean sealed) { + ES6Iterator.initialize( + ITER_DESCRIPTOR, + cx, + (TopLevel) scope, + new NativeCollectionIterator(ITERATOR_TAG), + sealed, + ITERATOR_TAG); + return DESCRIPTOR.buildConstructor(cx, scope, new NativeObject(), sealed); } @Override @@ -94,16 +88,19 @@ public String getClassName() { return CLASS_NAME; } - private static Scriptable jsConstructor(Context cx, VarScope scope, Object[] args) { + private static Scriptable js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeSet ns = new NativeSet(); ns.instanceOfSet = true; if (args.length > 0) { - loadFromIterable(cx, scope, ns, NativeMap.key(args)); + loadFromIterable(cx, s, ns, NativeMap.key(args)); } + ScriptRuntime.setBuiltinProtoAndParent(ns, f, nt, s, TopLevel.Builtins.Set); return ns; } - private static Object js_add(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_add( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeSet realThis = realThis(thisObj, "add"); var k = NativeMap.key(args); return realThis.js_add(k); @@ -119,7 +116,8 @@ private Object js_add(Object k) { return this; } - private static Object js_delete(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_delete( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeSet realThis = realThis(thisObj, "add"); var arg = NativeMap.key(args); return realThis.js_delete(arg); @@ -129,7 +127,8 @@ private Object js_delete(Object arg) { return entries.deleteEntry(arg); } - private static Object js_has(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_has( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeSet realThis = realThis(thisObj, "add"); var arg = NativeMap.key(args); return realThis.js_has(arg); @@ -143,7 +142,8 @@ private Object js_has(Object arg) { return entries.has(arg); } - private static Object js_clear(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_clear( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeSet realThis = realThis(thisObj, "add"); return realThis.js_clear(); } @@ -153,34 +153,34 @@ private Object js_clear() { return Undefined.instance; } - private static Object js_getSize(Context cx, VarScope scope, Object thisObj, Object[] args) { - NativeSet realThis = realThis(thisObj, "add"); - return realThis.js_getSize(); - } - private Object js_getSize() { return entries.size(); } - private static Object js_values(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_values( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeSet realThis = realThis(thisObj, "add"); - return realThis(thisObj, "values").js_iterator(scope, NativeCollectionIterator.Type.VALUES); + return realThis(thisObj, "values") + .js_iterator(f.getDeclarationScope(), NativeCollectionIterator.Type.VALUES); } - private static Object js_entries(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_entries( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeSet realThis = realThis(thisObj, "add"); - return realThis(thisObj, "values").js_iterator(scope, NativeCollectionIterator.Type.BOTH); + return realThis(thisObj, "values") + .js_iterator(f.getDeclarationScope(), NativeCollectionIterator.Type.BOTH); } private Object js_iterator(VarScope scope, NativeCollectionIterator.Type type) { return new NativeCollectionIterator(scope, ITERATOR_TAG, type, entries.iterator()); } - private static Object js_forEach(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_forEach( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "forEach") .js_forEach( cx, - scope, + f.getDeclarationScope(), NativeMap.key(args), args.length > 1 ? args[1] : Undefined.SCRIPTABLE_UNDEFINED); } @@ -192,9 +192,8 @@ private Object js_forEach(Context cx, VarScope scope, Object arg1, Object arg2) final Function f = (Function) arg1; for (Hashtable.Entry entry : entries) { - Scriptable thisObj = ScriptRuntime.getThisForScope(f.getDeclarationScope(), arg2); final Hashtable.Entry e = entry; - f.call(cx, scope, thisObj, new Object[] {e.value, e.value, this}); + f.call(cx, scope, arg2, new Object[] {e.value, e.value, this}); } return Undefined.instance; } @@ -243,8 +242,8 @@ private static NativeSet realThis(Object thisObj, String name) { // ES2025 Set Methods Implementation private static Object js_intersection( - Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "intersection").js_intersection(cx, scope, args); + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "intersection").js_intersection(cx, s, args); } private Object js_intersection(Context cx, VarScope scope, Object[] args) { @@ -329,8 +328,9 @@ private Object js_intersectionSetLike( return result; } - private static Object js_union(Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "union").js_union(cx, scope, args); + private static Object js_union( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "union").js_union(cx, s, args); } private Object js_union(Context cx, VarScope scope, Object[] args) { @@ -384,8 +384,9 @@ private Object js_union(Context cx, VarScope scope, Object[] args) { return result; } - private static Object js_difference(Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "difference").js_difference(cx, scope, args); + private static Object js_difference( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "difference").js_difference(cx, s, args); } private Object js_difference(Context cx, VarScope scope, Object[] args) { @@ -484,8 +485,8 @@ private Object js_differenceSetLike( } private static Object js_symmetricDifference( - Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "symmetricDifference").js_symmetricDifference(cx, scope, args); + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "symmetricDifference").js_symmetricDifference(cx, s, args); } private Object js_symmetricDifference(Context cx, VarScope scope, Object[] args) { @@ -547,8 +548,9 @@ private Object js_symmetricDifference(Context cx, VarScope scope, Object[] args) return result; } - private static Object js_isSubsetOf(Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "isSubsetOf").js_isSubsetOf(cx, scope, args); + private static Object js_isSubsetOf( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "isSubsetOf").js_isSubsetOf(cx, s, args); } private Object js_isSubsetOf(Context cx, VarScope scope, Object[] args) { @@ -605,8 +607,8 @@ private Object js_isSubsetOf(Context cx, VarScope scope, Object[] args) { } private static Object js_isSupersetOf( - Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "isSupersetOf").js_isSupersetOf(cx, scope, args); + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "isSupersetOf").js_isSupersetOf(cx, s, args); } private Object js_isSupersetOf(Context cx, VarScope scope, Object[] args) { @@ -654,8 +656,8 @@ private Object js_isSupersetOf(Context cx, VarScope scope, Object[] args) { } private static Object js_isDisjointFrom( - Context cx, VarScope scope, Object thisObj, Object[] args) { - return realThis(thisObj, "isDisjointFrom").js_isDisjointFrom(cx, scope, args); + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + return realThis(thisObj, "isDisjointFrom").js_isDisjointFrom(cx, s, args); } private Object js_isDisjointFrom(Context cx, VarScope scope, Object[] args) { diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeString.java b/rhino/src/main/java/org/mozilla/javascript/NativeString.java index e8e2db35c39..a44b9c34c50 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeString.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeString.java @@ -6,6 +6,8 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; import static org.mozilla.javascript.ScriptRuntime.rangeError; import static org.mozilla.javascript.ScriptRuntimeES6.requireObjectCoercible; @@ -18,6 +20,7 @@ import java.util.Locale; import java.util.Map; import org.mozilla.javascript.AbstractEcmaStringOperations.ReplacementOperation; +import org.mozilla.javascript.ClassDescriptor.BuiltInJSCodeExec; import org.mozilla.javascript.ScriptRuntime.StringIdOrIndex; /** @@ -39,145 +42,132 @@ final class NativeString extends ScriptableObject { private final CharSequence string; - static void init(VarScope scope, boolean sealed) { - LambdaConstructor c = - new LambdaConstructor( - scope, - CLASS_NAME, - 1, - NativeString::js_constructorFunc, - NativeString::js_constructor); - c.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - c.setPrototypeScriptable(new NativeString("")); - - defConsMethod(c, scope, "fromCharCode", 1, NativeString::js_fromCharCode); - defConsMethod(c, scope, "fromCodePoint", 1, NativeString::js_fromCodePoint); - defConsMethod(c, scope, "raw", 1, NativeString::js_raw); - - /* - * All of the methods below are on the constructor for compatibility with ancient Rhino - * versions. They are no longer part of ECMAScript. The "wrapConstructor" method is a - * technique used in the past in Rhino to adapt the instance functions so that they - * may be called on the constructor directly. - */ - defConsMethod(c, scope, "charAt", 1, wrapConstructor(NativeString::js_charAt)); - defConsMethod(c, scope, "charCodeAt", 1, wrapConstructor(NativeString::js_charCodeAt)); - defConsMethod(c, scope, "indexOf", 2, wrapConstructor(NativeString::js_indexOf)); - defConsMethod(c, scope, "lastIndexOf", 2, wrapConstructor(NativeString::js_lastIndexOf)); - defConsMethod(c, scope, "split", 3, wrapConstructor(NativeString::js_split)); - defConsMethod(c, scope, "substring", 3, wrapConstructor(NativeString::js_substring)); - defConsMethod(c, scope, "toLowerCase", 1, wrapConstructor(NativeString::js_toLowerCase)); - defConsMethod(c, scope, "toUpperCase", 1, wrapConstructor(NativeString::js_toUpperCase)); - defConsMethod(c, scope, "substr", 3, wrapConstructor(NativeString::js_substr)); - defConsMethod(c, scope, "concat", 2, wrapConstructor(NativeString::js_concat)); - defConsMethod(c, scope, "slice", 3, wrapConstructor(NativeString::js_slice)); - defConsMethod( - c, - scope, - "equalsIgnoreCase", - 2, - wrapConstructor(NativeString::js_equalsIgnoreCase)); - defConsMethod(c, scope, "match", 2, wrapConstructor(NativeString::js_match)); - defConsMethod(c, scope, "search", 2, wrapConstructor(NativeString::js_search)); - defConsMethod(c, scope, "replace", 2, wrapConstructor(NativeString::js_replace)); - defConsMethod(c, scope, "replaceAll", 2, wrapConstructor(NativeString::js_replaceAll)); - defConsMethod( - c, scope, "localeCompare", 2, wrapConstructor(NativeString::js_localeCompare)); - defConsMethod( - c, - scope, - "toLocaleLowerCase", - 1, - wrapConstructor(NativeString::js_toLocaleLowerCase)); - - /* Back to prototype methods -- these are all part of ECMAScript */ - defProtoMethod(c, scope, SymbolKey.ITERATOR, 0, NativeString::js_iterator); - defProtoMethod(c, scope, "toString", 0, NativeString::js_toString); - defProtoMethod(c, scope, "toSource", 0, NativeString::js_toSource); - defProtoMethod(c, scope, "valueOf", 0, NativeString::js_toString); - defProtoMethod(c, scope, "charAt", 1, NativeString::js_charAt); - defProtoMethod(c, scope, "charCodeAt", 1, NativeString::js_charCodeAt); - defProtoMethod(c, scope, "indexOf", 1, NativeString::js_indexOf); - defProtoMethod(c, scope, "lastIndexOf", 1, NativeString::js_lastIndexOf); - defProtoMethod(c, scope, "split", 2, NativeString::js_split); - defProtoMethod(c, scope, "substring", 2, NativeString::js_substring); - defProtoMethod(c, scope, "toLowerCase", 0, NativeString::js_toLowerCase); - defProtoMethod(c, scope, "toUpperCase", 0, NativeString::js_toUpperCase); - defProtoMethod(c, scope, "substr", 2, NativeString::js_substr); - defProtoMethod(c, scope, "concat", 1, NativeString::js_concat); - defProtoMethod(c, scope, "slice", 2, NativeString::js_slice); - defProtoMethod(c, scope, "bold", 0, NativeString::js_bold); - defProtoMethod(c, scope, "italics", 0, NativeString::js_italics); - defProtoMethod(c, scope, "fixed", 0, NativeString::js_fixed); - defProtoMethod(c, scope, "strike", 0, NativeString::js_strike); - defProtoMethod(c, scope, "small", 0, NativeString::js_small); - defProtoMethod(c, scope, "big", 0, NativeString::js_big); - defProtoMethod(c, scope, "blink", 0, NativeString::js_blink); - defProtoMethod(c, scope, "sup", 0, NativeString::js_sup); - defProtoMethod(c, scope, "sub", 0, NativeString::js_sub); - defProtoMethod(c, scope, "fontsize", 0, NativeString::js_fontsize); - defProtoMethod(c, scope, "fontcolor", 0, NativeString::js_fontcolor); - defProtoMethod(c, scope, "link", 0, NativeString::js_link); - defProtoMethod(c, scope, "anchor", 0, NativeString::js_anchor); - defProtoMethod(c, scope, "equals", 1, NativeString::js_equals); - defProtoMethod(c, scope, "equalsIgnoreCase", 1, NativeString::js_equalsIgnoreCase); - defProtoMethod(c, scope, "match", 1, NativeString::js_match); - defProtoMethod(c, scope, "matchAll", 1, NativeString::js_matchAll); - defProtoMethod(c, scope, "search", 1, NativeString::js_search); - defProtoMethod(c, scope, "replace", 2, NativeString::js_replace); - defProtoMethod(c, scope, "replaceAll", 2, NativeString::js_replaceAll); - defProtoMethod(c, scope, "at", 1, NativeString::js_at); - defProtoMethod(c, scope, "localeCompare", 1, NativeString::js_localeCompare); - defProtoMethod(c, scope, "toLocaleLowerCase", 0, NativeString::js_toLocaleLowerCase); - defProtoMethod(c, scope, "toLocaleUpperCase", 0, NativeString::js_toLocaleUpperCase); - defProtoMethod(c, scope, "trim", 0, NativeString::js_trim); - defProtoMethod(c, scope, "trimLeft", 0, NativeString::js_trimLeft); - defProtoMethod(c, scope, "trimStart", 0, NativeString::js_trimLeft); - defProtoMethod(c, scope, "trimRight", 0, NativeString::js_trimRight); - defProtoMethod(c, scope, "trimEnd", 0, NativeString::js_trimRight); - defProtoMethod(c, scope, "includes", 1, NativeString::js_includes); - defProtoMethod(c, scope, "startsWith", 1, NativeString::js_startsWith); - defProtoMethod(c, scope, "endsWith", 1, NativeString::js_endsWith); - defProtoMethod(c, scope, "normalize", 0, NativeString::js_normalize); - defProtoMethod(c, scope, "repeat", 1, NativeString::js_repeat); - defProtoMethod(c, scope, "codePointAt", 1, NativeString::js_codePointAt); - defProtoMethod(c, scope, "padStart", 1, NativeString::js_padStart); - defProtoMethod(c, scope, "padEnd", 1, NativeString::js_padEnd); - defProtoMethod(c, scope, "isWellFormed", 0, NativeString::js_isWellFormed); - defProtoMethod(c, scope, "toWellFormed", 0, NativeString::js_toWellFormed); - - if (sealed) { - c.sealObject(); - ((NativeString) c.getPrototypeProperty()).sealObject(); - } - ScriptableObject.defineProperty(scope, CLASS_NAME, c, DONTENUM); - } - - private static void defConsMethod( - LambdaConstructor c, - VarScope scope, - String name, - int length, - SerializableCallable target) { - c.defineConstructorMethod(scope, name, length, target); - } - - private static void defProtoMethod( - LambdaConstructor c, - VarScope scope, - SymbolKey key, - int length, - SerializableCallable target) { - c.definePrototypeMethod(scope, key, length, target); - } - - private static void defProtoMethod( - LambdaConstructor c, - VarScope scope, - String name, - int length, - SerializableCallable target) { - c.definePrototypeMethod(scope, name, length, target); + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 1, + NativeString::js_constructorFunc, + NativeString::js_constructor) + .withMethod(CTOR, "fromCharCode", 1, NativeString::js_fromCharCode) + .withMethod(CTOR, "fromCodePoint", 1, NativeString::js_fromCodePoint) + .withMethod(CTOR, "raw", 1, NativeString::js_raw) + + /* + * All of the methods below are on the constructor for compatibility with ancient Rhino + * versions. They are no longer part of ECMAScript. The "wrapConstructor" method is a + * technique used in the past in Rhino to adapt the instance functions so that they + * may be called on the constructor directly. + */ + .withMethod(CTOR, "charAt", 1, forCtor(NativeString::js_charAt)) + .withMethod(CTOR, "charCodeAt", 1, forCtor(NativeString::js_charCodeAt)) + .withMethod(CTOR, "indexOf", 2, forCtor(NativeString::js_indexOf)) + .withMethod(CTOR, "lastIndexOf", 2, forCtor(NativeString::js_lastIndexOf)) + .withMethod(CTOR, "split", 3, forCtor(NativeString::js_split)) + .withMethod(CTOR, "substring", 3, forCtor(NativeString::js_substring)) + .withMethod(CTOR, "toLowerCase", 1, forCtor(NativeString::js_toLowerCase)) + .withMethod(CTOR, "toUpperCase", 1, forCtor(NativeString::js_toUpperCase)) + .withMethod(CTOR, "substr", 3, forCtor(NativeString::js_substr)) + .withMethod(CTOR, "concat", 2, forCtor(NativeString::js_concat)) + .withMethod(CTOR, "slice", 3, forCtor(NativeString::js_slice)) + .withMethod( + CTOR, + "equalsIgnoreCase", + 2, + forCtor(NativeString::js_equalsIgnoreCase)) + .withMethod(CTOR, "match", 2, forCtor(NativeString::js_match)) + .withMethod(CTOR, "search", 2, forCtor(NativeString::js_search)) + .withMethod(CTOR, "replace", 2, forCtor(NativeString::js_replace)) + .withMethod(CTOR, "replaceAll", 2, forCtor(NativeString::js_replaceAll)) + .withMethod( + CTOR, "localeCompare", 2, forCtor(NativeString::js_localeCompare)) + .withMethod( + CTOR, + "toLocaleLowerCase", + 1, + forCtor(NativeString::js_toLocaleLowerCase)) + + /* Back to prototype methods -- these are all part of ECMAScript */ + + .withMethod(PROTO, SymbolKey.ITERATOR, 0, NativeString::js_iterator) + .withMethod(PROTO, "toString", 0, NativeString::js_toString) + .withMethod(PROTO, "toSource", 0, NativeString::js_toSource) + .withMethod(PROTO, "valueOf", 0, NativeString::js_toString) + .withMethod(PROTO, "charAt", 1, NativeString::js_charAt) + .withMethod(PROTO, "charCodeAt", 1, NativeString::js_charCodeAt) + .withMethod(PROTO, "indexOf", 1, NativeString::js_indexOf) + .withMethod(PROTO, "lastIndexOf", 1, NativeString::js_lastIndexOf) + .withMethod(PROTO, "split", 2, NativeString::js_split) + .withMethod(PROTO, "substring", 2, NativeString::js_substring) + .withMethod(PROTO, "toLowerCase", 0, NativeString::js_toLowerCase) + .withMethod(PROTO, "toUpperCase", 0, NativeString::js_toUpperCase) + .withMethod(PROTO, "substr", 2, NativeString::js_substr) + .withMethod(PROTO, "concat", 1, NativeString::js_concat) + .withMethod(PROTO, "slice", 2, NativeString::js_slice) + .withMethod(PROTO, "bold", 0, NativeString::js_bold) + .withMethod(PROTO, "italics", 0, NativeString::js_italics) + .withMethod(PROTO, "fixed", 0, NativeString::js_fixed) + .withMethod(PROTO, "strike", 0, NativeString::js_strike) + .withMethod(PROTO, "small", 0, NativeString::js_small) + .withMethod(PROTO, "big", 0, NativeString::js_big) + .withMethod(PROTO, "blink", 0, NativeString::js_blink) + .withMethod(PROTO, "sup", 0, NativeString::js_sup) + .withMethod(PROTO, "sub", 0, NativeString::js_sub) + .withMethod(PROTO, "fontsize", 0, NativeString::js_fontsize) + .withMethod(PROTO, "fontcolor", 0, NativeString::js_fontcolor) + .withMethod(PROTO, "link", 0, NativeString::js_link) + .withMethod(PROTO, "anchor", 0, NativeString::js_anchor) + .withMethod(PROTO, "equals", 1, NativeString::js_equals) + .withMethod(PROTO, "equalsIgnoreCase", 1, NativeString::js_equalsIgnoreCase) + .withMethod(PROTO, "match", 1, NativeString::js_match) + .withMethod(PROTO, "matchAll", 1, NativeString::js_matchAll) + .withMethod(PROTO, "search", 1, NativeString::js_search) + .withMethod(PROTO, "replace", 2, NativeString::js_replace) + .withMethod(PROTO, "replaceAll", 2, NativeString::js_replaceAll) + .withMethod(PROTO, "at", 1, NativeString::js_at) + .withMethod(PROTO, "localeCompare", 1, NativeString::js_localeCompare) + .withMethod( + PROTO, "toLocaleLowerCase", 0, NativeString::js_toLocaleLowerCase) + .withMethod( + PROTO, "toLocaleUpperCase", 0, NativeString::js_toLocaleUpperCase) + .withMethod(PROTO, "trim", 0, NativeString::js_trim) + .withMethod(PROTO, "trimLeft", 0, NativeString::js_trimLeft) + .withMethod(PROTO, "trimStart", 0, NativeString::js_trimLeft) + .withMethod(PROTO, "trimRight", 0, NativeString::js_trimRight) + .withMethod(PROTO, "trimEnd", 0, NativeString::js_trimRight) + .withMethod(PROTO, "includes", 1, NativeString::js_includes) + .withMethod(PROTO, "startsWith", 1, NativeString::js_startsWith) + .withMethod(PROTO, "endsWith", 1, NativeString::js_endsWith) + .withMethod(PROTO, "normalize", 0, NativeString::js_normalize) + .withMethod(PROTO, "repeat", 1, NativeString::js_repeat) + .withMethod(PROTO, "codePointAt", 1, NativeString::js_codePointAt) + .withMethod(PROTO, "padStart", 1, NativeString::js_padStart) + .withMethod(PROTO, "padEnd", 1, NativeString::js_padEnd) + .withMethod(PROTO, "isWellFormed", 0, NativeString::js_isWellFormed) + .withMethod(PROTO, "toWellFormed", 0, NativeString::js_toWellFormed) + .build(); + } + + private static BuiltInJSCodeExec forCtor(BuiltInJSCodeExec code) { + return (cx, f, nt, s, thisObj, args) -> { + Object[] realArgs; + Object realThis; + if (args.length > 0) { + realThis = ScriptRuntime.toObject(cx, s, ScriptRuntime.toCharSequence(args[0])); + realArgs = new Object[args.length - 1]; + System.arraycopy(args, 1, realArgs, 0, realArgs.length); + } else { + realThis = ScriptRuntime.toObject(cx, s, ScriptRuntime.toCharSequence(thisObj)); + realArgs = args; + } + return code.execute(cx, f, nt, s, realThis, realArgs); + }; + } + + static void init(Context cx, VarScope scope, boolean sealed) { + DESCRIPTOR.buildConstructor(cx, scope, new NativeString(""), sealed); } NativeString(CharSequence s) { @@ -192,52 +182,37 @@ public String getClassName() { return CLASS_NAME; } - private static SerializableCallable wrapConstructor(SerializableCallable target) { - return (Context cx, VarScope scope, Scriptable origThis, Object[] origArgs) -> { - Scriptable thisObj; - Object[] newArgs; - if (origArgs.length > 0) { - thisObj = - ScriptRuntime.toObject( - cx, scope, ScriptRuntime.toCharSequence(origArgs[0])); - newArgs = new Object[origArgs.length - 1]; - System.arraycopy(origArgs, 1, newArgs, 0, newArgs.length); - } else { - thisObj = ScriptRuntime.toObject(cx, scope, ScriptRuntime.toCharSequence(origThis)); - newArgs = origArgs; - } - return target.call(cx, scope, thisObj, newArgs); - }; - } - - private static Scriptable js_constructor(Context cx, VarScope scope, Object[] args) { - CharSequence s; + private static Scriptable js_constructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + CharSequence str; if (args.length == 0) { - s = ""; + str = ""; } else { - s = ScriptRuntime.toCharSequence(args[0]); + str = ScriptRuntime.toCharSequence(args[0]); } - return new NativeString(s); + var res = new NativeString(str); + ScriptRuntime.setBuiltinProtoAndParent(res, f, nt, s, TopLevel.Builtins.String); + return res; } private static Object js_constructorFunc( - Context cx, VarScope scope, Object thisObj, Object[] args) { - CharSequence s; + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + CharSequence str; if (args.length == 0) { - s = ""; + str = ""; } else if (ScriptRuntime.isSymbol(args[0])) { // 19.4.3.2 et.al. Convert a symbol to a string with String() but not // new String() - s = args[0].toString(); + str = args[0].toString(); } else { - s = ScriptRuntime.toCharSequence(args[0]); + str = ScriptRuntime.toCharSequence(args[0]); } // String(val) converts val to a string value. - return s instanceof String ? s : s.toString(); + return str instanceof String ? str : str.toString(); } private static Object js_fromCharCode( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { int n = args.length; if (n < 1) { return ""; @@ -250,7 +225,7 @@ private static Object js_fromCharCode( } private static Object js_fromCodePoint( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { int n = args.length; if (n < 1) { return ""; @@ -268,11 +243,13 @@ private static Object js_fromCodePoint( return new String(codePoints, 0, n); } - private static Object js_charAt(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_charAt( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return charAt(cx, thisObj, args, false); } - private static Object js_charCodeAt(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_charCodeAt( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return charAt(cx, thisObj, args, true); } @@ -291,7 +268,8 @@ private static Object charAt(Context cx, Object thisObj, Object[] args, boolean return ScriptRuntime.wrapInt(c); } - private static Object js_indexOf(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_indexOf( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String target = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "indexOf")); String searchStr = ScriptRuntime.toString(args, 0); @@ -307,7 +285,8 @@ private static Object js_indexOf(Context cx, VarScope scope, Object thisObj, Obj return target.indexOf(searchStr, (int) position); } - private static Object js_startsWith(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_startsWith( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String target = ScriptRuntime.toString( requireObjectCoercible(cx, thisObj, CLASS_NAME, "startsWith")); @@ -319,7 +298,8 @@ private static Object js_startsWith(Context cx, VarScope scope, Object thisObj, return target.startsWith(searchStr, (int) position); } - private static Object js_endsWith(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_endsWith( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String target = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "endsWith")); checkValidRegex(cx, args, 0, "endsWith"); @@ -333,7 +313,8 @@ private static Object js_endsWith(Context cx, VarScope scope, Object thisObj, Ob return target.substring(0, (int) position).endsWith(searchStr); } - private static Object js_includes(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_includes( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String target = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "includes")); String searchStr = ScriptRuntime.toString(args, 0); @@ -358,20 +339,21 @@ private static void checkValidRegex(Context cx, Object[] args, int pos, String f } } - private static Object js_split(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_split( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // See ECMAScript spec 22.1.3.23 Object o = requireObjectCoercible(cx, thisObj, CLASS_NAME, "split"); if (cx.getLanguageVersion() <= Context.VERSION_1_8) { // Use old algorithm for backward compatibility return ScriptRuntime.checkRegExpProxy(cx) - .js_split(cx, scope, ScriptRuntime.toString(o), args); + .js_split(cx, s, ScriptRuntime.toString(o), args); } Object separator = args.length > 0 ? args[0] : Undefined.instance; Object limit = args.length > 1 ? args[1] : Undefined.instance; if (!Undefined.isUndefined(separator) && separator != null) { - Object splitter = ScriptRuntime.getObjectElem(separator, SymbolKey.SPLIT, cx, scope); + Object splitter = ScriptRuntime.getObjectElem(separator, SymbolKey.SPLIT, cx, s); // If method is not undefined, it should be a Callable if (splitter != null && !Undefined.isUndefined(splitter)) { if (!(splitter instanceof Callable)) { @@ -381,8 +363,8 @@ private static Object js_split(Context cx, VarScope scope, Object thisObj, Objec return ((Callable) splitter) .call( cx, - scope, - ScriptRuntime.toObject(scope, separator), + s, + ScriptRuntime.toObject(s, separator), new Object[] { o instanceof NativeString ? ((NativeString) o).string : o, limit, @@ -390,7 +372,7 @@ private static Object js_split(Context cx, VarScope scope, Object thisObj, Objec } } - String s = ScriptRuntime.toString(o); + String str = ScriptRuntime.toString(o); long lim; if (Undefined.isUndefined(limit)) { lim = Integer.MAX_VALUE; @@ -399,17 +381,17 @@ private static Object js_split(Context cx, VarScope scope, Object thisObj, Objec } String r = ScriptRuntime.toString(separator); if (lim == 0) { - return cx.newArray(scope, 0); + return cx.newArray(s, 0); } if (Undefined.isUndefined(separator)) { - return cx.newArray(scope, new Object[] {s}); + return cx.newArray(s, new Object[] {str}); } int separatorLength = r.length(); if (separatorLength == 0) { - int strLen = s.length(); + int strLen = str.length(); int outLen = ScriptRuntime.clamp((int) lim, 0, strLen); - String head = s.substring(0, outLen); + String head = str.substring(0, outLen); List codeUnits = new ArrayList<>(); for (int i = 0; i < head.length(); ) { @@ -417,49 +399,53 @@ private static Object js_split(Context cx, VarScope scope, Object thisObj, Objec codeUnits.add(Character.toString(c)); i += Character.charCount(c); } - return cx.newArray(scope, codeUnits.toArray()); + return cx.newArray(s, codeUnits.toArray()); } - if (s.isEmpty()) { - return cx.newArray(scope, new Object[] {s}); + if (str.isEmpty()) { + return cx.newArray(s, new Object[] {str}); } List substrings = new ArrayList<>(); int i = 0; - int j = s.indexOf(r); + int j = str.indexOf(r); while (j != -1) { - String t = s.substring(i, j); + String t = str.substring(i, j); substrings.add(t); if (substrings.size() >= lim) { - return cx.newArray(scope, substrings.toArray()); + return cx.newArray(s, substrings.toArray()); } i = j + separatorLength; - j = s.indexOf(r, i); + j = str.indexOf(r, i); } - String t = s.substring(i); + String t = str.substring(i); substrings.add(t); - return cx.newArray(scope, substrings.toArray()); + return cx.newArray(s, substrings.toArray()); } private static NativeString realThis(Object thisObj) { return LambdaConstructor.convertThisObject(thisObj, NativeString.class); } - private static Object js_iterator(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_iterator( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return new NativeStringIterator( - scope, requireObjectCoercible(cx, thisObj, CLASS_NAME, "[Symbol.iterator]")); + f.getDeclarationScope(), + requireObjectCoercible(cx, thisObj, CLASS_NAME, "[Symbol.iterator]")); } - private static Object js_toString(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_toString( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // ECMA 15.5.4.2: the toString function is not generic. CharSequence cs = realThis(thisObj).string; return cs instanceof String ? cs : cs.toString(); } - private static Object js_toSource(Context cx, VarScope scope, Object thisObj, Object[] args) { - CharSequence s = realThis(thisObj).string; - return "(new String(\"" + ScriptRuntime.escapeString(s.toString()) + "\"))"; + private static Object js_toSource( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { + CharSequence str = realThis(thisObj).string; + return "(new String(\"" + ScriptRuntime.escapeString(str.toString()) + "\"))"; } /* @@ -576,12 +562,13 @@ private ScriptableObject.DescriptorInfo defaultIndexPropertyDescriptor(Object va * See ECMA 22.1.3.13 * */ - private static Object js_match(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_match( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Object o = requireObjectCoercible(cx, thisObj, CLASS_NAME, "match"); Object regexp = args.length > 0 ? args[0] : Undefined.instance; RegExpProxy regExpProxy = ScriptRuntime.checkRegExpProxy(cx); if (regexp != null && !Undefined.isUndefined(regexp)) { - Object matcher = ScriptRuntime.getObjectElem(regexp, SymbolKey.MATCH, cx, scope); + Object matcher = ScriptRuntime.getObjectElem(regexp, SymbolKey.MATCH, cx, s); // If method is not undefined, it should be a Callable if (matcher != null && !Undefined.isUndefined(matcher)) { if (!(matcher instanceof Callable)) { @@ -589,11 +576,11 @@ private static Object js_match(Context cx, VarScope scope, Object thisObj, Objec regexp, matcher, SymbolKey.MATCH.getName()); } return ((Callable) matcher) - .call(cx, scope, ScriptRuntime.toObject(scope, regexp), new Object[] {o}); + .call(cx, s, ScriptRuntime.toObject(s, regexp), new Object[] {o}); } } - String s = ScriptRuntime.toString(o); + String str = ScriptRuntime.toString(o); String regexpToString = Undefined.isUndefined(regexp) ? "" : ScriptRuntime.toString(regexp); String flags = null; @@ -604,13 +591,13 @@ private static Object js_match(Context cx, VarScope scope, Object thisObj, Objec } Object compiledRegExp = regExpProxy.compileRegExp(cx, regexpToString, flags); - Scriptable rx = regExpProxy.wrapRegExp(cx, scope, compiledRegExp); + Scriptable rx = regExpProxy.wrapRegExp(cx, s, compiledRegExp); - Object method = ScriptRuntime.getObjectElem(rx, SymbolKey.MATCH, cx, scope); + Object method = ScriptRuntime.getObjectElem(rx, SymbolKey.MATCH, cx, s); if (!(method instanceof Callable)) { throw ScriptRuntime.notFunctionError(rx, method, SymbolKey.MATCH.getName()); } - return ((Callable) method).call(cx, scope, rx, new Object[] {s}); + return ((Callable) method).call(cx, s, rx, new Object[] {str}); } /* @@ -619,7 +606,7 @@ private static Object js_match(Context cx, VarScope scope, Object thisObj, Objec * */ private static Object js_lastIndexOf( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String target = ScriptRuntime.toString( requireObjectCoercible(cx, thisObj, CLASS_NAME, "lastIndexOf")); @@ -635,7 +622,8 @@ private static Object js_lastIndexOf( /* * See ECMA 15.5.4.15 */ - private static Object js_substring(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_substring( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { CharSequence target = ScriptRuntime.toCharSequence( requireObjectCoercible(cx, thisObj, CLASS_NAME, "substring")); @@ -664,7 +652,7 @@ private static Object js_substring(Context cx, VarScope scope, Object thisObj, O } private static Object js_toLowerCase( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // See ECMA 15.5.4.11 String thisStr = ScriptRuntime.toString( @@ -673,7 +661,7 @@ private static Object js_toLowerCase( } private static Object js_toUpperCase( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // See ECMA 15.5.4.12 String thisStr = ScriptRuntime.toString( @@ -689,7 +677,7 @@ int getLength() { * Non-ECMA methods. */ private static CharSequence js_substr( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { CharSequence target = ScriptRuntime.toCharSequence( requireObjectCoercible(cx, thisObj, CLASS_NAME, "substr")); @@ -730,7 +718,8 @@ private static CharSequence js_substr( /* * Python-esque sequence operations. */ - private static String js_concat(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static String js_concat( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String target = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "concat")); int N = args.length; @@ -746,9 +735,9 @@ private static String js_concat(Context cx, VarScope scope, Object thisObj, Obje int size = target.length(); String[] argsAsStrings = new String[N]; for (int i = 0; i != N; ++i) { - String s = ScriptRuntime.toString(args[i]); - argsAsStrings[i] = s; - size += s.length(); + String str = ScriptRuntime.toString(args[i]); + argsAsStrings[i] = str; + size += str.length(); } StringBuilder result = new StringBuilder(size); @@ -759,7 +748,8 @@ private static String js_concat(Context cx, VarScope scope, Object thisObj, Obje return result.toString(); } - private static Object js_slice(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_slice( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { CharSequence target = ScriptRuntime.toCharSequence( requireObjectCoercible(cx, thisObj, CLASS_NAME, "slice")); @@ -788,7 +778,8 @@ private static Object js_slice(Context cx, VarScope scope, Object thisObj, Objec return target.subSequence((int) begin, (int) end); } - private static Object js_at(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_at( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "at")); Object targetArg = (args.length >= 1) ? args[0] : Undefined.instance; int len = str.length(); @@ -803,25 +794,27 @@ private static Object js_at(Context cx, VarScope scope, Object thisObj, Object[] return str.substring(k, k + 1); } - private static Object js_equals(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_equals( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String s1 = ScriptRuntime.toString(thisObj); String s2 = ScriptRuntime.toString(args, 0); return s1.equals(s2); } private static Object js_equalsIgnoreCase( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String s1 = ScriptRuntime.toString(thisObj); String s2 = ScriptRuntime.toString(args, 0); return s1.equalsIgnoreCase(s2); } - private static Object js_search(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_search( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { Object o = requireObjectCoercible(cx, thisObj, CLASS_NAME, "search"); Object regexp = args.length > 0 ? args[0] : Undefined.instance; RegExpProxy regExpProxy = ScriptRuntime.checkRegExpProxy(cx); if (regexp != null && !Undefined.isUndefined(regexp)) { - Object matcher = ScriptRuntime.getObjectElem(regexp, SymbolKey.SEARCH, cx, scope); + Object matcher = ScriptRuntime.getObjectElem(regexp, SymbolKey.SEARCH, cx, s); // If method is not undefined, it should be a Callable if (matcher != null && !Undefined.isUndefined(matcher)) { if (!(matcher instanceof Callable)) { @@ -829,11 +822,11 @@ private static Object js_search(Context cx, VarScope scope, Object thisObj, Obje regexp, matcher, SymbolKey.SEARCH.getName()); } return ((Callable) matcher) - .call(cx, scope, ScriptRuntime.toObject(scope, regexp), new Object[] {o}); + .call(cx, s, ScriptRuntime.toObject(s, regexp), new Object[] {o}); } } - String s = ScriptRuntime.toString(o); + String str = ScriptRuntime.toString(o); String regexpToString = Undefined.isUndefined(regexp) ? "" : ScriptRuntime.toString(regexp); String flags = null; @@ -843,23 +836,24 @@ private static Object js_search(Context cx, VarScope scope, Object thisObj, Obje } Object compiledRegExp = regExpProxy.compileRegExp(cx, regexpToString, flags); - Scriptable rx = regExpProxy.wrapRegExp(cx, scope, compiledRegExp); + Scriptable rx = regExpProxy.wrapRegExp(cx, s, compiledRegExp); - Object method = ScriptRuntime.getObjectElem(rx, SymbolKey.SEARCH, cx, scope); + Object method = ScriptRuntime.getObjectElem(rx, SymbolKey.SEARCH, cx, s); if (!(method instanceof Callable)) { throw ScriptRuntime.notFunctionError(rx, method, SymbolKey.SEARCH.getName()); } - return ((Callable) method).call(cx, scope, rx, new Object[] {s}); + return ((Callable) method).call(cx, s, rx, new Object[] {str}); } - private static Object js_replace(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_replace( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // See ECMAScript spec 22.1.3.19 Object o = requireObjectCoercible(cx, thisObj, CLASS_NAME, "replace"); if (cx.getLanguageVersion() <= Context.VERSION_1_8) { // Use old algorithm for backward compatibility return ScriptRuntime.checkRegExpProxy(cx) - .action(cx, scope, thisObj, args, RegExpProxy.RA_REPLACE); + .action(cx, s, thisObj, args, RegExpProxy.RA_REPLACE); } // Spec-compliant algorithm @@ -868,8 +862,7 @@ private static Object js_replace(Context cx, VarScope scope, Object thisObj, Obj Object replaceValue = args.length > 1 ? args[1] : Undefined.instance; if (!Undefined.isUndefined(searchValue) && searchValue != null) { - Object replacer = - ScriptRuntime.getObjectElem(searchValue, SymbolKey.REPLACE, cx, scope); + Object replacer = ScriptRuntime.getObjectElem(searchValue, SymbolKey.REPLACE, cx, s); // If method is not undefined, it should be a Callable if (replacer != null && !Undefined.isUndefined(replacer)) { if (!(replacer instanceof Callable)) { @@ -879,8 +872,8 @@ private static Object js_replace(Context cx, VarScope scope, Object thisObj, Obj return ((Callable) replacer) .call( cx, - scope, - ScriptRuntime.toObject(scope, searchValue), + s, + ScriptRuntime.toObject(s, searchValue), new Object[] { o instanceof NativeString ? ((NativeString) o).string : o, replaceValue @@ -911,13 +904,13 @@ private static Object js_replace(Context cx, VarScope scope, Object thisObj, Obj String replacement; if (functionalReplace) { Scriptable callThis = - ScriptRuntime.getApplyOrCallThis(cx, scope, null, 0, (Function) replaceValue); + ScriptRuntime.getApplyOrCallThis(cx, s, null, 0, (Function) replaceValue); Object replacementObj = ((Callable) replaceValue) .call( cx, - scope, + s, callThis, new Object[] { searchString, position, string, @@ -928,7 +921,7 @@ private static Object js_replace(Context cx, VarScope scope, Object thisObj, Obj replacement = AbstractEcmaStringOperations.getSubstitution( cx, - scope, + s, searchString, string, position, @@ -939,7 +932,8 @@ private static Object js_replace(Context cx, VarScope scope, Object thisObj, Obj return preceding + replacement + following; } - private static Object js_replaceAll(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_replaceAll( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // See ECMAScript spec 22.1.3.20 Object o = requireObjectCoercible(cx, thisObj, CLASS_NAME, "replaceAll"); @@ -949,9 +943,9 @@ private static Object js_replaceAll(Context cx, VarScope scope, Object thisObj, if (searchValue != null && !Undefined.isUndefined(searchValue)) { boolean isRegExp = searchValue instanceof Scriptable - && AbstractEcmaObjectOperations.isRegExp(cx, scope, searchValue); + && AbstractEcmaObjectOperations.isRegExp(cx, s, searchValue); if (isRegExp) { - Object flags = ScriptRuntime.getObjectProp(searchValue, "flags", cx, scope); + Object flags = ScriptRuntime.getObjectProp(searchValue, "flags", cx, s); requireObjectCoercible(cx, flags, CLASS_NAME, "replaceAll"); String flagsStr = ScriptRuntime.toString(flags); if (!flagsStr.contains("g")) { @@ -959,7 +953,7 @@ private static Object js_replaceAll(Context cx, VarScope scope, Object thisObj, } } - Object matcher = ScriptRuntime.getObjectElem(searchValue, SymbolKey.REPLACE, cx, scope); + Object matcher = ScriptRuntime.getObjectElem(searchValue, SymbolKey.REPLACE, cx, s); // If method is not undefined, it should be a Callable if (matcher != null && !Undefined.isUndefined(matcher)) { if (!(matcher instanceof Callable)) { @@ -969,8 +963,8 @@ private static Object js_replaceAll(Context cx, VarScope scope, Object thisObj, return ((Callable) matcher) .call( cx, - scope, - ScriptRuntime.toObject(scope, searchValue), + s, + ScriptRuntime.toObject(s, searchValue), new Object[] {o, replaceValue}); } } @@ -1006,14 +1000,13 @@ private static Object js_replaceAll(Context cx, VarScope scope, Object thisObj, String replacement; if (functionalReplace) { Scriptable callThis = - ScriptRuntime.getApplyOrCallThis( - cx, scope, null, 0, (Function) replaceValue); + ScriptRuntime.getApplyOrCallThis(cx, s, null, 0, (Function) replaceValue); Object replacementObj = ((Callable) replaceValue) .call( cx, - scope, + s, callThis, new Object[] { searchString, p, string, @@ -1024,7 +1017,7 @@ private static Object js_replaceAll(Context cx, VarScope scope, Object thisObj, replacement = AbstractEcmaStringOperations.getSubstitution( cx, - scope, + s, searchString, string, p, @@ -1042,14 +1035,15 @@ private static Object js_replaceAll(Context cx, VarScope scope, Object thisObj, return result.toString(); } - private static Object js_matchAll(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_matchAll( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // See ECMAScript spec 22.1.3.14 Object o = requireObjectCoercible(cx, thisObj, CLASS_NAME, "matchAll"); Object regexp = args.length > 0 ? args[0] : Undefined.instance; if (regexp != null && !Undefined.isUndefined(regexp)) { - boolean isRegExp = AbstractEcmaObjectOperations.isRegExp(cx, scope, regexp); + boolean isRegExp = AbstractEcmaObjectOperations.isRegExp(cx, s, regexp); if (isRegExp) { - Object flags = ScriptRuntime.getObjectProp(regexp, "flags", cx, scope); + Object flags = ScriptRuntime.getObjectProp(regexp, "flags", cx, s); requireObjectCoercible(cx, flags, CLASS_NAME, "matchAll"); String flagsStr = ScriptRuntime.toString(flags); if (!flagsStr.contains("g")) { @@ -1057,7 +1051,7 @@ private static Object js_matchAll(Context cx, VarScope scope, Object thisObj, Ob } } - Object matcher = ScriptRuntime.getObjectElem(regexp, SymbolKey.MATCH_ALL, cx, scope); + Object matcher = ScriptRuntime.getObjectElem(regexp, SymbolKey.MATCH_ALL, cx, s); // If method is not undefined, it should be a Callable if (matcher != null && !Undefined.isUndefined(matcher)) { if (!(matcher instanceof Callable)) { @@ -1065,25 +1059,25 @@ private static Object js_matchAll(Context cx, VarScope scope, Object thisObj, Ob regexp, matcher, SymbolKey.MATCH_ALL.getName()); } return ((Callable) matcher) - .call(cx, scope, ScriptRuntime.toObject(scope, regexp), new Object[] {o}); + .call(cx, s, ScriptRuntime.toObject(s, regexp), new Object[] {o}); } } - String s = ScriptRuntime.toString(o); + String str = ScriptRuntime.toString(o); String regexpToString = Undefined.isUndefined(regexp) ? "" : ScriptRuntime.toString(regexp); RegExpProxy regExpProxy = ScriptRuntime.checkRegExpProxy(cx); Object compiledRegExp = regExpProxy.compileRegExp(cx, regexpToString, "g"); - Scriptable rx = regExpProxy.wrapRegExp(cx, scope, compiledRegExp); + Scriptable rx = regExpProxy.wrapRegExp(cx, s, compiledRegExp); - Object method = ScriptRuntime.getObjectElem(rx, SymbolKey.MATCH_ALL, cx, scope); + Object method = ScriptRuntime.getObjectElem(rx, SymbolKey.MATCH_ALL, cx, s); if (!(method instanceof Callable)) { throw ScriptRuntime.notFunctionError(rx, method, SymbolKey.MATCH_ALL.getName()); } - return ((Callable) method).call(cx, scope, rx, new Object[] {s}); + return ((Callable) method).call(cx, s, rx, new Object[] {str}); } private static Object js_localeCompare( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { // For now, create and configure a collator instance. I can't // actually imagine that this'd be slower than caching them // a la ClassCache, so we aren't trying to outsmart ourselves @@ -1098,7 +1092,7 @@ private static Object js_localeCompare( } private static Object js_toLocaleLowerCase( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String thisStr = ScriptRuntime.toString( requireObjectCoercible(cx, thisObj, CLASS_NAME, "toLocaleLowerCase")); @@ -1115,7 +1109,7 @@ private static Object js_toLocaleLowerCase( } private static Object js_toLocaleUpperCase( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String thisStr = ScriptRuntime.toString( requireObjectCoercible(cx, thisObj, CLASS_NAME, "toLocaleUpperCase")); @@ -1131,7 +1125,8 @@ private static Object js_toLocaleUpperCase( return thisStr.toUpperCase(locale); } - private static Object js_trim(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_trim( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "trim")); char[] chars = str.toCharArray(); @@ -1148,7 +1143,8 @@ private static Object js_trim(Context cx, VarScope scope, Object thisObj, Object return str.substring(start, end); } - private static Object js_trimLeft(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_trimLeft( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "trimLeft")); char[] chars = str.toCharArray(); @@ -1162,7 +1158,8 @@ private static Object js_trimLeft(Context cx, VarScope scope, Object thisObj, Ob return str.substring(start, end); } - private static Object js_trimRight(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_trimRight( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString( requireObjectCoercible(cx, thisObj, CLASS_NAME, "trimRight")); @@ -1178,7 +1175,8 @@ private static Object js_trimRight(Context cx, VarScope scope, Object thisObj, O return str.substring(start, end); } - private static Object js_normalize(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_normalize( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { if (args.length == 0 || Undefined.isUndefined(args[0])) { return Normalizer.normalize( ScriptRuntime.toString( @@ -1203,7 +1201,8 @@ private static Object js_normalize(Context cx, VarScope scope, Object thisObj, O form); } - private static String js_repeat(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static String js_repeat( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString(requireObjectCoercible(cx, thisObj, CLASS_NAME, "repeat")); double cnt = ScriptRuntime.toInteger(args, 0); @@ -1239,7 +1238,7 @@ private static String js_repeat(Context cx, VarScope scope, Object thisObj, Obje } private static Object js_codePointAt( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { String str = ScriptRuntime.toString( requireObjectCoercible(cx, thisObj, CLASS_NAME, "codePointAt")); @@ -1288,11 +1287,13 @@ private static String pad( return concat.insert(0, pad).toString(); } - private static Object js_padStart(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_padStart( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return pad(cx, thisObj, "padStart", args, true); } - private static Object js_padEnd(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_padEnd( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return pad(cx, thisObj, "padEnd", args, false); } @@ -1303,13 +1304,14 @@ private static Object js_padEnd(Context cx, VarScope scope, Object thisObj, Obje * *

22.1.2.4 String.raw [Draft ECMA-262 / April 28, 2021] */ - private static Object js_raw(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_raw( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { /* step 1-2 */ Object arg0 = args.length > 0 ? args[0] : Undefined.instance; - Scriptable cooked = ScriptRuntime.toObject(cx, scope, arg0); + Scriptable cooked = ScriptRuntime.toObject(cx, s, arg0); /* step 3 */ Object rawValue = ScriptRuntime.getObjectProp(cooked, "raw", cx); - Scriptable raw = ScriptRuntime.toObject(cx, scope, rawValue); + Scriptable raw = ScriptRuntime.toObject(cx, s, rawValue); /* step 4-5 */ long rawLength = NativeArray.getLengthProperty(cx, raw); if (rawLength > Integer.MAX_VALUE) { @@ -1341,7 +1343,7 @@ private static Object js_raw(Context cx, VarScope scope, Object thisObj, Object[ } private static Object js_isWellFormed( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { CharSequence str = ScriptRuntime.toCharSequence( requireObjectCoercible(cx, thisObj, CLASS_NAME, "isWellFormed")); @@ -1367,7 +1369,7 @@ private static Object js_isWellFormed( } private static Object js_toWellFormed( - Context cx, VarScope scope, Object thisObj, Object[] args) { + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { CharSequence str = ScriptRuntime.toCharSequence( requireObjectCoercible(cx, thisObj, CLASS_NAME, "toWellFormed")); @@ -1413,55 +1415,68 @@ private static Object js_toWellFormed( return sb.toString(); } - private static Object js_bold(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_bold( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "bold", "b", null, args); } - private static Object js_italics(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_italics( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "italics", "i", null, args); } - private static Object js_fixed(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_fixed( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "fixed", "tt", null, args); } - private static Object js_strike(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_strike( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "strike", "strike", null, args); } - private static Object js_small(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_small( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "small", "small", null, args); } - private static Object js_big(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_big( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "big", "big", null, args); } - private static Object js_blink(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_blink( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "blink", "blink", null, args); } - private static Object js_sup(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_sup( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "sup", "sup", null, args); } - private static Object js_sub(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_sub( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "sub", "sub", null, args); } - private static Object js_fontsize(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_fontsize( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "fontsize", "font", "size", args); } - private static Object js_fontcolor(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_fontcolor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "fontcolor", "font", "color", args); } - private static Object js_link(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_link( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "link", "a", "href", args); } - private static Object js_anchor(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_anchor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return tagify(cx, thisObj, "anchor", "a", "name", args); } } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeStringIterator.java b/rhino/src/main/java/org/mozilla/javascript/NativeStringIterator.java index 989aa3c5f1a..6c28cb541f8 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeStringIterator.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeStringIterator.java @@ -7,11 +7,15 @@ package org.mozilla.javascript; public final class NativeStringIterator extends ES6Iterator { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 6709689999500242078L; private static final String ITERATOR_TAG = "StringIterator"; - static void init(TopLevel scope, boolean sealed) { - ES6Iterator.init(scope, sealed, new NativeStringIterator(), ITERATOR_TAG); + private static final ClassDescriptor DESCRIPTOR = + ES6Iterator.makeDescriptor(ITERATOR_TAG, "String Iterator"); + + static void init(Context cx, VarScope scope, boolean sealed) { + ES6Iterator.initialize( + DESCRIPTOR, cx, (TopLevel) scope, new NativeStringIterator(), sealed, ITERATOR_TAG); } /** Only for constructing the prototype object. */ diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeWeakMap.java b/rhino/src/main/java/org/mozilla/javascript/NativeWeakMap.java index 0b3c6c92a3c..d32419c33bf 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeWeakMap.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeWeakMap.java @@ -6,6 +6,10 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + import java.io.IOException; import java.io.ObjectInputStream; import java.util.WeakHashMap; @@ -23,6 +27,27 @@ public class NativeWeakMap extends ScriptableObject { private static final String CLASS_NAME = "WeakMap"; + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 0, + ClassDescriptor.typeError(), + NativeWeakMap::jsConstructor) + .withMethod(PROTO, "set", 2, NativeWeakMap::js_set) + .withMethod(PROTO, "delete", 1, NativeWeakMap::js_delete) + .withMethod(PROTO, "get", 1, NativeWeakMap::js_get) + .withMethod(PROTO, "has", 1, NativeWeakMap::js_has) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value(CLASS_NAME, DONTENUM | READONLY)) + .withProp(CTOR, SymbolKey.SPECIES, ScriptRuntimeES6::symbolSpecies) + .build(); + } + private boolean instanceOfWeakMap = false; private transient WeakHashMap map = new WeakHashMap<>(); @@ -30,29 +55,7 @@ public class NativeWeakMap extends ScriptableObject { private static final Object NULL_VALUE = new Object(); static Object init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - CLASS_NAME, - 0, - LambdaConstructor.CONSTRUCTOR_NEW, - NativeWeakMap::jsConstructor); - constructor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - - constructor.definePrototypeMethod(scope, "set", 2, NativeWeakMap::js_set); - constructor.definePrototypeMethod(scope, "delete", 1, NativeWeakMap::js_delete); - constructor.definePrototypeMethod(scope, "get", 1, NativeWeakMap::js_get); - constructor.definePrototypeMethod(scope, "has", 1, NativeWeakMap::js_has); - - constructor.definePrototypeProperty( - SymbolKey.TO_STRING_TAG, CLASS_NAME, DONTENUM | READONLY); - - ScriptRuntimeES6.addSymbolSpecies(cx, scope, constructor); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } - return constructor; + return DESCRIPTOR.buildConstructor(cx, scope, new NativeObject(), sealed); } @Override @@ -60,16 +63,19 @@ public String getClassName() { return CLASS_NAME; } - private static Scriptable jsConstructor(Context cx, VarScope scope, Object[] args) { + private static Scriptable jsConstructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeWeakMap nm = new NativeWeakMap(); nm.instanceOfWeakMap = true; if (args.length > 0) { - NativeMap.loadFromIterable(cx, scope, nm, NativeMap.key(args)); + NativeMap.loadFromIterable(cx, f.getDeclarationScope(), nm, NativeMap.key(args)); } + ScriptRuntime.setBuiltinProtoAndParent(nm, f, nt, s, TopLevel.Builtins.WeakMap); return nm; } - private static Object js_delete(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_delete( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "delete").js_delete(NativeMap.key(args)); } @@ -80,7 +86,8 @@ private Object js_delete(Object key) { return map.remove(key) != null; } - private static Object js_get(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_get( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "get").js_get(NativeMap.key(args)); } @@ -97,7 +104,8 @@ private Object js_get(Object key) { return result; } - private static Object js_has(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_has( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "has").js_has(NativeMap.key(args)); } @@ -108,7 +116,8 @@ private Object js_has(Object key) { return map.containsKey(key); } - private static Object js_set(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_set( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { return realThis(thisObj, "set") .js_set(NativeMap.key(args), args.length > 1 ? args[1] : Undefined.instance); } diff --git a/rhino/src/main/java/org/mozilla/javascript/NativeWeakSet.java b/rhino/src/main/java/org/mozilla/javascript/NativeWeakSet.java index 292ec94d518..0c6330f018a 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NativeWeakSet.java +++ b/rhino/src/main/java/org/mozilla/javascript/NativeWeakSet.java @@ -6,6 +6,10 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ClassDescriptor.Builder.value; +import static org.mozilla.javascript.ClassDescriptor.Destination.CTOR; +import static org.mozilla.javascript.ClassDescriptor.Destination.PROTO; + import java.io.IOException; import java.io.ObjectInputStream; import java.util.WeakHashMap; @@ -21,33 +25,32 @@ public class NativeWeakSet extends ScriptableObject { private static final String CLASS_NAME = "WeakSet"; + private static final ClassDescriptor DESCRIPTOR; + + static { + DESCRIPTOR = + new ClassDescriptor.Builder( + CLASS_NAME, + 0, + ClassDescriptor.typeError(), + NativeWeakSet::jsConstructor) + .withMethod(PROTO, "add", 1, NativeWeakSet::js_add) + .withMethod(PROTO, "delete", 1, NativeWeakSet::js_delete) + .withMethod(PROTO, "has", 1, NativeWeakSet::js_has) + .withProp( + PROTO, + SymbolKey.TO_STRING_TAG, + value(CLASS_NAME, DONTENUM | READONLY)) + .withProp(CTOR, SymbolKey.SPECIES, ScriptRuntimeES6::symbolSpecies) + .build(); + } + private boolean instanceOfWeakSet = false; private transient WeakHashMap map = new WeakHashMap<>(); static Object init(Context cx, VarScope scope, boolean sealed) { - LambdaConstructor constructor = - new LambdaConstructor( - scope, - CLASS_NAME, - 0, - LambdaConstructor.CONSTRUCTOR_NEW, - NativeWeakSet::jsConstructor); - constructor.setPrototypePropertyAttributes(DONTENUM | READONLY | PERMANENT); - - constructor.definePrototypeMethod(scope, "add", 1, NativeWeakSet::js_add); - constructor.definePrototypeMethod(scope, "delete", 1, NativeWeakSet::js_delete); - constructor.definePrototypeMethod(scope, "has", 1, NativeWeakSet::js_has); - - constructor.definePrototypeProperty( - SymbolKey.TO_STRING_TAG, CLASS_NAME, DONTENUM | READONLY); - - ScriptRuntimeES6.addSymbolSpecies(cx, scope, constructor); - if (sealed) { - constructor.sealObject(); - ((ScriptableObject) constructor.getPrototypeProperty()).sealObject(); - } - return constructor; + return DESCRIPTOR.buildConstructor(cx, scope, new NativeObject(), sealed); } @Override @@ -55,16 +58,19 @@ public String getClassName() { return CLASS_NAME; } - private static Scriptable jsConstructor(Context cx, VarScope scope, Object[] args) { + private static Scriptable jsConstructor( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeWeakSet ns = new NativeWeakSet(); ns.instanceOfWeakSet = true; if (args.length > 0) { - NativeSet.loadFromIterable(cx, scope, ns, NativeMap.key(args)); + NativeSet.loadFromIterable(cx, f.getDeclarationScope(), ns, NativeMap.key(args)); } + ScriptRuntime.setBuiltinProtoAndParent(ns, f, nt, s, TopLevel.Builtins.WeakSet); return ns; } - private static Object js_add(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_add( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeWeakSet realThis = realThis(thisObj, "add"); var k = NativeMap.key(args); return realThis.js_add(k); @@ -84,7 +90,8 @@ private Object js_add(Object key) { return this; } - private static Object js_delete(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_delete( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeWeakSet realThis = realThis(thisObj, "add"); var arg = NativeMap.key(args); return realThis.js_delete(arg); @@ -97,7 +104,8 @@ private Object js_delete(Object key) { return map.remove(key) != null; } - private static Object js_has(Context cx, VarScope scope, Object thisObj, Object[] args) { + private static Object js_has( + Context cx, JSFunction f, Object nt, VarScope s, Object thisObj, Object[] args) { NativeWeakSet realThis = realThis(thisObj, "add"); var arg = NativeMap.key(args); return realThis.js_has(arg); diff --git a/rhino/src/main/java/org/mozilla/javascript/Node.java b/rhino/src/main/java/org/mozilla/javascript/Node.java index a65a4c18243..35b0461a147 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Node.java +++ b/rhino/src/main/java/org/mozilla/javascript/Node.java @@ -604,14 +604,20 @@ public static Node newTarget() { } public final int labelId() { - if ((type != Token.TARGET) && (type != Token.YIELD) && (type != Token.YIELD_STAR)) { + if ((type != Token.TARGET) + && (type != Token.YIELD) + && (type != Token.YIELD_STAR) + && (type != Token.AWAIT)) { Kit.codeBug(); } return getIntProp(LABEL_ID_PROP, -1); } public void labelId(int labelId) { - if ((type != Token.TARGET) && (type != Token.YIELD) && (type != Token.YIELD_STAR)) { + if ((type != Token.TARGET) + && (type != Token.YIELD) + && (type != Token.YIELD_STAR) + && (type != Token.AWAIT)) { Kit.codeBug(); } putIntProp(LABEL_ID_PROP, labelId); @@ -968,7 +974,7 @@ public boolean hasSideEffects() { case Token.ASSIGN_EXP: case Token.ASSIGN_NULLISH: case Token.ENTERWITH: - case Token.LEAVEWITH: + case Token.LEAVE_SCOPE: case Token.RETURN: case Token.GOTO: case Token.IFEQ: diff --git a/rhino/src/main/java/org/mozilla/javascript/NodeTransformer.java b/rhino/src/main/java/org/mozilla/javascript/NodeTransformer.java index 2f754175c0c..c10de902e8c 100644 --- a/rhino/src/main/java/org/mozilla/javascript/NodeTransformer.java +++ b/rhino/src/main/java/org/mozilla/javascript/NodeTransformer.java @@ -118,7 +118,18 @@ private void transformCompilationUnit_r( { loops.push(node); Node leave = node.getNext(); - if (leave.getType() != Token.LEAVEWITH) { + if (leave.getType() != Token.LEAVE_SCOPE) { + Kit.codeBug(); + } + loopEnds.push(leave); + break; + } + + case Token.SCOPE_BLOCK: + { + loops.push(node); + Node leave = node.getNext(); + if (leave.getType() != Token.LEAVE_SCOPE) { Kit.codeBug(); } loopEnds.push(leave); @@ -138,7 +149,7 @@ private void transformCompilationUnit_r( } case Token.TARGET: - case Token.LEAVEWITH: + case Token.LEAVE_SCOPE: if (!loopEnds.isEmpty() && loopEnds.peek() == node) { loopEnds.pop(); loops.pop(); @@ -147,6 +158,7 @@ private void transformCompilationUnit_r( case Token.YIELD: case Token.YIELD_STAR: + case Token.AWAIT: ((FunctionNode) tree).addResumptionPoint(node); break; @@ -170,14 +182,16 @@ private void transformCompilationUnit_r( // Iterate from the top of the stack (most recently inserted) and down for (Node n : loops) { int elemtype = n.getType(); - if (elemtype == Token.TRY || elemtype == Token.WITH) { + if (elemtype == Token.TRY + || elemtype == Token.WITH + || elemtype == Token.SCOPE_BLOCK) { Node unwind; if (elemtype == Token.TRY) { Jump jsrnode = new Jump(Token.JSR); jsrnode.target = ((Jump) n).getFinally(); unwind = jsrnode; } else { - unwind = new Node(Token.LEAVEWITH); + unwind = new Node(Token.LEAVE_SCOPE); } if (unwindBlock == null) { unwindBlock = new Node(Token.BLOCK); @@ -227,8 +241,10 @@ private void transformCompilationUnit_r( } int elemtype = n.getType(); - if (elemtype == Token.WITH) { - Node leave = new Node(Token.LEAVEWITH); + if (elemtype == Token.WITH + || elemtype == Token.SCOPEEXPR + || elemtype == Token.SCOPE_BLOCK) { + Node leave = new Node(Token.LEAVE_SCOPE); previous = addBeforeCurrent(parent, previous, node, leave); } else if (elemtype == Token.TRY) { Jump tryNode = (Jump) n; @@ -432,19 +448,18 @@ protected void visitNew(Node node, ScriptNode tree) {} protected void visitCall(Node node, ScriptNode tree) {} - protected Node visitLet(boolean createWith, Node parent, Node previous, Node scopeNode) { + protected Node visitLet(boolean createScope, Node parent, Node previous, Node scopeNode) { Node vars = scopeNode.getFirstChild(); Node body = vars.getNext(); scopeNode.removeChild(vars); scopeNode.removeChild(body); boolean isExpression = scopeNode.getType() == Token.LETEXPR; Node result; - Node newVars; - if (createWith) { - result = new Node(isExpression ? Token.WITHEXPR : Token.BLOCK); + Node newVars = new Node(Token.ENTER_SCOPE); + if (createScope) { + result = new Node(isExpression ? Token.SCOPEEXPR : Token.BLOCK); result = replaceCurrent(parent, previous, scopeNode, result); ArrayList list = new ArrayList<>(); - Node objectLiteral = new Node(Token.OBJECTLIT); for (Node v = vars.getFirstChild(); v != null; v = v.getNext()) { Node current = v; if (current.getType() == Token.LETEXPR) { @@ -464,7 +479,7 @@ protected Node visitLet(boolean createWith, Node parent, Node previous, Node sco if (destructuringNames != null) { list.addAll(destructuringNames); for (int i = 0; i < destructuringNames.size(); i++) { - objectLiteral.addChildToBack(new Node(Token.VOID, Node.newNumber(0.0))); + newVars.addChildToBack(new Node(Token.VOID, Node.newNumber(0.0))); } } // Process all NAME children of the inner LET node (not just the first) @@ -477,7 +492,7 @@ protected Node visitLet(boolean createWith, Node parent, Node previous, Node sco if (init == null) { init = new Node(Token.VOID, Node.newNumber(0.0)); } - objectLiteral.addChildToBack(init); + newVars.addChildToBack(init); } continue; // Already processed all children, move to next sibling of LETEXPR } @@ -487,13 +502,12 @@ protected Node visitLet(boolean createWith, Node parent, Node previous, Node sco if (init == null) { init = new Node(Token.VOID, Node.newNumber(0.0)); } - objectLiteral.addChildToBack(init); + newVars.addChildToBack(init); } - objectLiteral.putProp(Node.OBJECT_IDS_PROP, list.toArray()); - newVars = new Node(Token.ENTERWITH, objectLiteral); + newVars.putProp(Node.OBJECT_IDS_PROP, list.toArray()); result.addChildToBack(newVars); - result.addChildToBack(new Node(Token.WITH, body)); - result.addChildToBack(new Node(Token.LEAVEWITH)); + result.addChildToBack(new Node(Token.SCOPE_BLOCK, body)); + result.addChildToBack(new Node(Token.LEAVE_SCOPE)); } else { result = new Node(isExpression ? Token.COMMA : Token.BLOCK); result = replaceCurrent(parent, previous, scopeNode, result); diff --git a/rhino/src/main/java/org/mozilla/javascript/Parser.java b/rhino/src/main/java/org/mozilla/javascript/Parser.java index 2e5e1775f1d..2408d63ddd5 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Parser.java +++ b/rhino/src/main/java/org/mozilla/javascript/Parser.java @@ -21,6 +21,7 @@ import org.mozilla.javascript.ast.Assignment; import org.mozilla.javascript.ast.AstNode; import org.mozilla.javascript.ast.AstRoot; +import org.mozilla.javascript.ast.AwaitExpression; import org.mozilla.javascript.ast.BigIntLiteral; import org.mozilla.javascript.ast.Block; import org.mozilla.javascript.ast.BreakStatement; @@ -147,6 +148,13 @@ public class Parser { Scope currentScope; private int endFlags; private boolean inForInit; // bound temporarily during forStatement() + private boolean + inSingleStatementContext; // true when parsing a single-statement body (if/while/for + private boolean inSingleStatementDeclContext; // true when parsing a + // single-statement body + // that allows lexical + // declarations. without + // braces) private Map labelSet; private List loopSet; private List loopAndSwitchSet; @@ -486,6 +494,11 @@ boolean insideFunctionBody() { return nestingOfFunction != 0; } + private boolean insideAsyncFunction() { + return currentScriptOrFn instanceof FunctionNode + && ((FunctionNode) currentScriptOrFn).isAsync(); + } + boolean insideFunctionParams() { return nestingOfFunctionParams != 0; } @@ -743,9 +756,10 @@ private AstNode parseFunctionBody(int type, FunctionNode fnNode) throws IOExcept reportError("msg.default.args.use.strict"); } // "use strict" not allowed with non-simple params - if (fnNode.hasRestParameter()) { + if (fnNode.hasRestParameter() || fnNode.hasDestructuring()) { reportError("msg.rest.param.use.strict"); } + inUseStrictDirective = true; fnNode.setInStrictMode(true); } @@ -935,10 +949,15 @@ private void parseFunctionParams(FunctionNode fnNode) throws IOException { } private FunctionNode function(int type) throws IOException { - return function(type, false); + return function(type, false, false); } private FunctionNode function(int type, boolean isMethodDefiniton) throws IOException { + return function(type, isMethodDefiniton, false); + } + + private FunctionNode function(int type, boolean isMethodDefiniton, boolean isAsync) + throws IOException { boolean isGenerator = false; int syntheticType = type; int baseLineno = lineNumber(); // line number where source starts @@ -991,8 +1010,13 @@ private FunctionNode function(int type, boolean isMethodDefiniton) throws IOExce if (syntheticType != FunctionNode.FUNCTION_EXPRESSION && name != null && name.length() > 0) { - // Function statements define a symbol in the enclosing scope - defineSymbol(Token.FUNCTION, name.getIdentifier()); + if (type == FunctionNode.FUNCTION_BLOCK_SCOPED) { + // Block-scoped function in strict mode: define as let-like binding + defineSymbol(Token.LET, name.getIdentifier()); + } else { + // Function statements define a symbol in the enclosing scope + defineSymbol(Token.FUNCTION, name.getIdentifier()); + } } FunctionNode fnNode = new FunctionNode(functionSourceStart, name); @@ -1001,6 +1025,9 @@ private FunctionNode function(int type, boolean isMethodDefiniton) throws IOExce if (isGenerator) { fnNode.setIsES6Generator(); } + if (isAsync) { + fnNode.setIsAsync(); + } if (lpPos != -1) fnNode.setLp(lpPos - functionSourceStart); fnNode.setJsDocNode(getAndResetJsDoc()); @@ -1057,7 +1084,28 @@ private FunctionNode function(int type, boolean isMethodDefiniton) throws IOExce return fnNode; } - private AstNode arrowFunction(AstNode params, int startLine, int startColumn) + private ParenthesizedExpression callArgsToArrowParams(FunctionCall call) { + int absoluteLp = call.getPosition() + call.getLp(); + int absoluteRp = call.getPosition() + call.getRp(); + List args = call.getArguments(); + AstNode inner; + if (args.isEmpty()) { + inner = new EmptyExpression(absoluteLp + 1, 0); + } else { + inner = args.get(0); + for (int i = 1; i < args.size(); i++) { + inner = new InfixExpression(Token.COMMA, inner, args.get(i), 0); + } + } + ParenthesizedExpression paren = + new ParenthesizedExpression(absoluteLp, absoluteRp - absoluteLp + 1, inner); + if (call.getIntProp(Node.TRAILING_COMMA, 0) == 1) { + paren.putIntProp(Node.TRAILING_COMMA, 1); + } + return paren; + } + + private AstNode arrowFunction(AstNode params, int startLine, int startColumn, boolean isAsync) throws IOException { int baseLineno = lineNumber(); // line number where source starts int functionSourceStart = @@ -1066,6 +1114,9 @@ private AstNode arrowFunction(AstNode params, int startLine, int startColumn) FunctionNode fnNode = new FunctionNode(functionSourceStart); fnNode.setFunctionType(FunctionNode.ARROW_FUNCTION); fnNode.setJsDocNode(getAndResetJsDoc()); + if (isAsync) { + fnNode.setIsAsync(); + } // Would prefer not to call createDestructuringAssignment until codegen, // but the symbol definitions have to happen now, before body is parsed. @@ -1462,6 +1513,10 @@ private AstNode statementHelper() throws IOException { case Token.FUNCTION: consumeToken(); + if (inUseStrictDirective + && compilerEnv.getLanguageVersion() >= Context.VERSION_ES6) { + return function(FunctionNode.FUNCTION_BLOCK_SCOPED); + } return function(FunctionNode.FUNCTION_EXPRESSION_STATEMENT); case Token.DEFAULT: @@ -1525,6 +1580,10 @@ private IfStatement ifStatement() throws IOException { int pos = ts.tokenBeg, lineno = lineNumber(), elsePos = -1, column = columnNumber(); IfStatement pn = new IfStatement(pos); ConditionData data = condition(); + boolean isES6 = compilerEnv.getLanguageVersion() >= Context.VERSION_ES6; + boolean savedInSingleStatementContext = inSingleStatementContext; + inSingleStatementContext = isES6; + inSingleStatementDeclContext = inSingleStatementContext; AstNode ifTrue = getNextStatementAfterInlineComments(pn), ifFalse = null; if (matchToken(Token.ELSE, true)) { int tt = peekToken(); @@ -1533,8 +1592,12 @@ private IfStatement ifStatement() throws IOException { consumeToken(); } elsePos = ts.tokenBeg - pos; + inSingleStatementContext = isES6; + inSingleStatementDeclContext = inSingleStatementContext; ifFalse = statement(); } + inSingleStatementContext = savedInSingleStatementContext; + inSingleStatementDeclContext = savedInSingleStatementContext; int end = getNodeEnd(ifFalse != null ? ifFalse : ifTrue); pn.setLength(end - pos); pn.setCondition(data.condition); @@ -1646,7 +1709,13 @@ private WhileLoop whileLoop() throws IOException { ConditionData data = condition(); pn.setCondition(data.condition); pn.setParens(data.lp - pos, data.rp - pos); + boolean savedInSingleStatementContext = inSingleStatementContext; + boolean savedInSingleStatementDeclContext = inSingleStatementDeclContext; + inSingleStatementContext = compilerEnv.getLanguageVersion() >= Context.VERSION_ES6; + inSingleStatementDeclContext = false; AstNode body = getNextStatementAfterInlineComments(pn); + inSingleStatementContext = savedInSingleStatementContext; + inSingleStatementDeclContext = savedInSingleStatementDeclContext; pn.setLength(getNodeEnd(body) - pos); restoreRelativeLoopPosition(pn); pn.setBody(body); @@ -1664,7 +1733,13 @@ private DoLoop doLoop() throws IOException { pn.setLineColumnNumber(lineNumber(), columnNumber()); enterLoop(pn); try { + boolean savedInSingleStatementContext = inSingleStatementContext; + boolean savedInSingleStatementDeclContext = inSingleStatementDeclContext; + inSingleStatementContext = compilerEnv.getLanguageVersion() >= Context.VERSION_ES6; + inSingleStatementDeclContext = false; AstNode body = getNextStatementAfterInlineComments(pn); + inSingleStatementContext = savedInSingleStatementContext; + inSingleStatementDeclContext = savedInSingleStatementDeclContext; mustMatchToken(Token.WHILE, "msg.no.while.do", true); pn.setWhilePosition(ts.tokenBeg - pos); ConditionData data = condition(); @@ -1828,7 +1903,13 @@ && matchToken(Token.NAME, true) // break/continue statements to find the enclosing loop. enterLoop(pn); try { + boolean savedInSingleStatementContext = inSingleStatementContext; + boolean savedInSingleStatementDeclContext = inSingleStatementDeclContext; + inSingleStatementContext = compilerEnv.getLanguageVersion() >= Context.VERSION_ES6; + inSingleStatementDeclContext = false; AstNode body = getNextStatementAfterInlineComments(pn); + inSingleStatementContext = savedInSingleStatementContext; + inSingleStatementDeclContext = savedInSingleStatementDeclContext; pn.setLength(getNodeEnd(body) - forPos); restoreRelativeLoopPosition(pn); pn.setBody(body); @@ -2279,6 +2360,19 @@ && nowAllSet(before, endFlags, Node.END_YIELDS | Node.END_RETURNS_VALUE)) { return ret; } + private AstNode awaitExpression() throws IOException { + if (!insideAsyncFunction()) { + reportError("msg.bad.await"); + } + consumeToken(); // consume the "await" NAME token + int pos = ts.tokenBeg; + int lineno = lineNumber(), column = columnNumber(); + AstNode value = assignExpr(); + AwaitExpression node = new AwaitExpression(pos, getNodeEnd(value) - pos, value); + node.setLineColumnNumber(lineno, column); + return node; + } + private AstNode block() throws IOException { if (currentToken != Token.LC) codeBug(); consumeToken(); @@ -2286,6 +2380,10 @@ private AstNode block() throws IOException { Scope block = new Scope(pos); block.setLineColumnNumber(lineNumber(), columnNumber()); pushScope(block); + boolean savedInSingleStatementContext = inSingleStatementContext; + boolean savedInSingleStatementDeclContext = inSingleStatementDeclContext; + inSingleStatementContext = false; + inSingleStatementDeclContext = false; try { statements(block); mustMatchToken(Token.RC, "msg.no.brace.block", true); @@ -2293,6 +2391,8 @@ private AstNode block() throws IOException { return block; } finally { popScope(); + inSingleStatementContext = savedInSingleStatementContext; + inSingleStatementDeclContext = savedInSingleStatementDeclContext; } } @@ -2357,6 +2457,18 @@ private AstNode nameOrLabel() throws IOException { currentFlaggedToken |= TI_CHECK_LABEL; AstNode expr = expr(false); + if (expr instanceof FunctionNode) { + FunctionNode fn = (FunctionNode) expr; + if (fn.isAsync() + && fn.getFunctionType() == FunctionNode.FUNCTION_EXPRESSION + && fn.getFunctionName() != null + && fn.getFunctionName().length() > 0) { + fn.setFunctionType(FunctionNode.FUNCTION_EXPRESSION_STATEMENT); + defineSymbol(Token.FUNCTION, fn.getFunctionName().getIdentifier()); + return fn; + } + } + if (expr.getType() != Token.LABEL) { AstNode n = new ExpressionStatement(expr, !insideFunctionBody()); n.setLineColumnNumber(expr.getLineno(), expr.getColumn()); @@ -2541,6 +2653,16 @@ void defineSymbol(int declType, String name) { } void defineSymbol(int declType, String name, boolean ignoreNotInBlock) { + boolean isES6 = compilerEnv.getLanguageVersion() >= Context.VERSION_ES6; + + if (isES6) { + defineSymbolES6(declType, name, ignoreNotInBlock); + } else { + defineSymbolLegacy(declType, name, ignoreNotInBlock); + } + } + + void defineSymbolLegacy(int declType, String name, boolean ignoreNotInBlock) { if (name == null) { if (compilerEnv.isIdeMode()) { // be robust in IDE-mode return; @@ -2606,6 +2728,178 @@ else if (symDeclType == Token.LP) { } } + void defineSymbolES6(int declType, String name, boolean ignoreNotInBlock) { + if (name == null) { + if (compilerEnv.isIdeMode()) { // be robust in IDE-mode + return; + } + codeBug(); + } else if ("undefined".equals(name)) { + hasUndefinedBeenRedefined = true; + } + Scope definingScope = currentScope.getDefiningScope(name); + Symbol symbol = definingScope != null ? definingScope.getSymbol(name) : null; + Symbol varSymbol = currentScope.getVarSymbol(name); + int symDeclType = symbol != null ? symbol.getDeclType() : -1; + if (!isValidES6Redeclaration( + declType, symDeclType, symbol, varSymbol, currentScope, definingScope)) { + addError( + symDeclType == Token.CONST + ? "msg.const.redecl" + : symDeclType == Token.LET + ? "msg.let.redecl" + : symDeclType == Token.VAR + ? "msg.var.redecl" + : symDeclType == Token.FUNCTION + ? "msg.fn.redecl" + : "msg.parm.redecl", + name); + return; + } + switch (declType) { + case Token.LET: + if (!ignoreNotInBlock + && (inSingleStatementContext || currentScope instanceof Loop)) { + addError("msg.let.decl.not.in.block"); + return; + } + currentScope.putSymbol(new Symbol(declType, name)); + return; + + case Token.CONST: + if (!ignoreNotInBlock + && (inSingleStatementContext || currentScope instanceof Loop)) { + addError("msg.const.decl.not.in.block"); + return; + } + currentScope.putSymbol(new Symbol(declType, name)); + return; + // fall through for pre-ES6: const is function-scoped like var + case Token.FUNCTION: + if (!ignoreNotInBlock + && !inSingleStatementDeclContext + && (inSingleStatementContext || currentScope instanceof Loop)) { + addError("msg.function.decl.not.in.block"); + return; + } + case Token.VAR: + if (symbol != null) { + if (symDeclType == Token.VAR) addStrictWarning("msg.var.redecl", name); + else if (symDeclType == Token.LP) { + addStrictWarning("msg.var.hides.arg", name); + } + } else { + varSymbol = new Symbol(declType, name); + varSymbol.setDeclaredScope(currentScope); + currentScriptOrFn.putSymbol(varSymbol); + currentScriptOrFn.putVarSymbol(varSymbol); + // Record in every scope from the declaration site up to and + // including the enclosing function/script so each intermediate + // block scope knows which var-hoisted names originate within it. + for (Scope s = currentScope; s != currentScriptOrFn; s = s.getParentScope()) { + s.putVarSymbol(varSymbol); + } + } + return; + + case Token.LP: + if (symbol != null) { + // must be duplicate parameter. Second parameter hides the + // first, so go ahead and add the second parameter + addWarning("msg.dup.parms", name); + } + currentScriptOrFn.putSymbol(new Symbol(declType, name)); + return; + + default: + throw codeBug(); + } + } + + private boolean isValidES6Redeclaration( + int newDeclType, + int oldDeclType, + Symbol symbol, + Symbol varSymbol, + Scope currentScope, + Scope definingScope) { + return isSimpleRedefinition( + newDeclType, oldDeclType, symbol, varSymbol, currentScope, definingScope) + || (!maskingLexicalDefinition( + newDeclType, + oldDeclType, + symbol, + varSymbol, + currentScope, + definingScope) + && !maskingVarDefinition( + newDeclType, + oldDeclType, + symbol, + varSymbol, + currentScope, + definingScope)); + } + + private boolean isValidLegacyRedeclaration( + int newDeclType, + int oldDeclType, + Symbol symbol, + Symbol varSymbol, + Scope currentScope, + Scope definingScope) { + return !(symbol != null + && (oldDeclType == Token.CONST + || newDeclType == Token.CONST + || (definingScope == currentScope && oldDeclType == Token.LET))); + } + + private boolean isSimpleRedefinition( + int newDeclType, + int oldDeclType, + Symbol symbol, + Symbol varSymbol, + Scope currentScope, + Scope definingScope) { + return ((symbol != null + && currentScope == symbol.getDeclaredScope() + && oldDeclType != Token.FUNCTION + && newDeclType != Token.FUNCTION) + || currentScope == currentScriptOrFn) + && !Symbol.isDeclTypeLexical(oldDeclType) + && !Symbol.isDeclTypeLexical(newDeclType); + } + + private boolean maskingLexicalDefinition( + int newDeclType, + int oldDeclType, + Symbol symbol, + Symbol varSymbol, + Scope currentScope, + Scope definingScope) { + return (currentScope == definingScope && Symbol.isDeclTypeLexical(oldDeclType)) + || ((symbol != null + && symbol.isDeclTypeLexical() + && !Symbol.isDeclTypeLexical(newDeclType)) + || (varSymbol != null && Symbol.isDeclTypeLexical(newDeclType))); + } + + private boolean maskingVarDefinition( + int newDeclType, + int oldDeclType, + Symbol symbol, + Symbol varSymbol, + Scope currentScope, + Scope definingScope) { + if (currentScope != currentScriptOrFn && varSymbol != null) { + return true; + } + return (!Symbol.isDeclTypeLexical(newDeclType) + && symbol != null + && !symbol.isDeclTypeLexical()) + && newDeclType != oldDeclType; + } + private AstNode expr(boolean allowTrailingComma) throws IOException { AstNode pn = assignExpr(); int pos = pn.getPosition(); @@ -2628,6 +2922,9 @@ private AstNode assignExpr() throws IOException { if (tt == Token.YIELD) { return returnOrYield(tt, true); } + if (tt == Token.NAME && "await".equals(ts.getString()) && insideAsyncFunction()) { + return awaitExpression(); + } // Intentionally not calling lineNumber/columnNumber here! // We have not consumed any token yet, so the position would be invalid @@ -2664,7 +2961,17 @@ private AstNode assignExpr() throws IOException { } } else if (!hasEOL && tt == Token.ARROW) { consumeToken(); - pn = arrowFunction(pn, startLine, startColumn); + boolean isAsyncArrow = false; + AstNode arrowParams = pn; + if (pn instanceof FunctionCall) { + FunctionCall call = (FunctionCall) pn; + AstNode target = call.getTarget(); + if (target instanceof Name && "async".equals(((Name) target).getIdentifier())) { + isAsyncArrow = true; + arrowParams = callArgsToArrowParams(call); + } + } + pn = arrowFunction(arrowParams, startLine, startColumn, isAsyncArrow); } else if (pn.getIntProp(Node.OBJECT_LITERAL_DESTRUCTURING, 0) == 1 && !inDestructuringAssignment) { reportError("msg.syntax"); @@ -3055,6 +3362,20 @@ private AstNode memberExpr(boolean allowCallSyntax) throws IOException { } else { consumeToken(); int pos = ts.tokenBeg, lineno = lineNumber(), column = columnNumber(); + + // Detect new.target meta-property + if (peekToken() == Token.DOT) { + consumeToken(); // consume '.' + if (matchToken(Token.NAME, true) && "target".equals(ts.getString())) { + int end = ts.tokenEnd; + KeywordLiteral nt = new KeywordLiteral(pos, end - pos, Token.NEW_TARGET); + nt.setLineColumnNumber(lineno, column); + return memberExprTail(allowCallSyntax, nt); + } + reportError("msg.bad.new.dot"); + return makeErrorNode(); + } + NewExpression nx = new NewExpression(pos); AstNode target = memberExpr(false); @@ -3519,6 +3840,13 @@ private AstNode primaryExpr() throws IOException { case Token.NAME: consumeToken(); + if ("async".equals(ts.getString())) { + int nextTT = peekTokenOrEOL(); + if (nextTT == Token.FUNCTION) { + consumeToken(); + return function(FunctionNode.FUNCTION_EXPRESSION, false, true); + } + } return name(ttFlagged, tt); case Token.NUMBER: @@ -4049,9 +4377,15 @@ private ObjectLiteral objectLiteral() throws IOException { entryKind = GET_ENTRY; } else if ("set".equals(propertyName)) { entryKind = SET_ENTRY; + } else if ("async".equals(propertyName)) { + entryKind = METHOD_ENTRY; } } - if (entryKind == GET_ENTRY || entryKind == SET_ENTRY) { + boolean isAsyncMethod = + pname.getType() == Token.NAME + && "async".equals(propertyName) + && peeked != Token.LP; + if (entryKind == GET_ENTRY || entryKind == SET_ENTRY || isAsyncMethod) { pname = objliteralProperty(); if (pname == null) { reportError("msg.bad.prop"); @@ -4069,7 +4403,8 @@ private ObjectLiteral objectLiteral() throws IOException { pname, entryKind, pname instanceof GeneratorMethodDefinition, - true); + true, + isAsyncMethod); pname.setJsDocNode(jsdocNode); elems.add(objectProp); } @@ -4252,9 +4587,14 @@ private ObjectProperty plainProperty(AstNode property, int ptt) throws IOExcepti } private ObjectProperty methodDefinition( - int pos, AstNode propName, int entryKind, boolean isGenerator, boolean isShorthand) + int pos, + AstNode propName, + int entryKind, + boolean isGenerator, + boolean isShorthand, + boolean isAsync) throws IOException { - FunctionNode fn = function(FunctionNode.FUNCTION_EXPRESSION, true); + FunctionNode fn = function(FunctionNode.FUNCTION_EXPRESSION, true, isAsync); // We've already parsed the function name, so fn should be anonymous. Name name = fn.getFunctionName(); if (name != null && name.length() != 0) { @@ -5409,7 +5749,8 @@ void markDestructuring(AstNode node) { reportError("msg.parm.after.rest"); } } - } else if (node instanceof ParenthesizedExpression) { + } else if (compilerEnv.getLanguageVersion() < Context.VERSION_ES6 + && node instanceof ParenthesizedExpression) { markDestructuring(((ParenthesizedExpression) node).getExpression()); } } diff --git a/rhino/src/main/java/org/mozilla/javascript/PolicySecurityController.java b/rhino/src/main/java/org/mozilla/javascript/PolicySecurityController.java index 73bbe1726a5..d17e25f18d6 100644 --- a/rhino/src/main/java/org/mozilla/javascript/PolicySecurityController.java +++ b/rhino/src/main/java/org/mozilla/javascript/PolicySecurityController.java @@ -88,7 +88,7 @@ public Object callWithDomain( Context cx, Callable callable, VarScope scope, - Scriptable thisObj, + Object thisObj, Object[] args) { // Run in doPrivileged as we might be checked for "getClassLoader" // runtime permission @@ -145,7 +145,7 @@ public Object run() throws Exception { public abstract static class SecureCaller { public abstract Object call( - Callable callable, Context cx, VarScope scope, Scriptable thisObj, Object[] args); + Callable callable, Context cx, VarScope scope, Object thisObj, Object[] args); } private static byte[] loadBytecode() { diff --git a/rhino/src/main/java/org/mozilla/javascript/RefCallable.java b/rhino/src/main/java/org/mozilla/javascript/RefCallable.java index b8437ea3a9e..ad788ccc028 100644 --- a/rhino/src/main/java/org/mozilla/javascript/RefCallable.java +++ b/rhino/src/main/java/org/mozilla/javascript/RefCallable.java @@ -17,5 +17,5 @@ public interface RefCallable extends Callable { * @param thisObj the JavaScript {@code this} object * @param args the array of arguments */ - public Ref refCall(Context cx, Scriptable thisObj, Object[] args); + public Ref refCall(Context cx, Object thisObj, Object[] args); } diff --git a/rhino/src/main/java/org/mozilla/javascript/RegExpProxy.java b/rhino/src/main/java/org/mozilla/javascript/RegExpProxy.java index 5f245b3c457..ba57557a027 100644 --- a/rhino/src/main/java/org/mozilla/javascript/RegExpProxy.java +++ b/rhino/src/main/java/org/mozilla/javascript/RegExpProxy.java @@ -18,7 +18,7 @@ public interface RegExpProxy { public static final int RA_REPLACE_ALL = 3; public static final int RA_SEARCH = 4; - public void register(TopLevel scope, boolean sealed); + public void register(Context cx, TopLevel scope, boolean sealed); public boolean isRegExp(Scriptable obj); diff --git a/rhino/src/main/java/org/mozilla/javascript/ScopeObject.java b/rhino/src/main/java/org/mozilla/javascript/ScopeObject.java index ea48d09cf56..9966fe3781c 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ScopeObject.java +++ b/rhino/src/main/java/org/mozilla/javascript/ScopeObject.java @@ -10,7 +10,7 @@ import java.io.Serializable; public class ScopeObject extends SlotMapOwner implements VarScope, Serializable { - private static final long serialVersionUID = -7471457301304454454L; + private static final long serialVersionUID = 2283542168979106620L; private final VarScope parentScope; diff --git a/rhino/src/main/java/org/mozilla/javascript/ScopeWrapper.java b/rhino/src/main/java/org/mozilla/javascript/ScopeWrapper.java index 90e2616b2de..cf6022dc6ae 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ScopeWrapper.java +++ b/rhino/src/main/java/org/mozilla/javascript/ScopeWrapper.java @@ -1,7 +1,7 @@ package org.mozilla.javascript; public class ScopeWrapper extends ScriptableObject { - private static final long serialVersionUID = -7471457301304454454L; + private static final long serialVersionUID = -3481312197060837332L; private final VarScope scope; diff --git a/rhino/src/main/java/org/mozilla/javascript/Script.java b/rhino/src/main/java/org/mozilla/javascript/Script.java index 380bcd7c42b..ad469499c32 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Script.java +++ b/rhino/src/main/java/org/mozilla/javascript/Script.java @@ -42,7 +42,7 @@ default Object exec(Context cx, VarScope scope) { * @return the result of executing the script * @see org.mozilla.javascript.Context#initStandardObjects() */ - Object exec(Context cx, VarScope scope, Scriptable thisObj); + Object exec(Context cx, VarScope scope, Object thisObj); default JSDescriptor getDescriptor() { return null; diff --git a/rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java b/rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java index 17c3608ecd8..19bb9f4d500 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java +++ b/rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java @@ -6,6 +6,12 @@ package org.mozilla.javascript; +import static org.mozilla.javascript.ScriptableObject.DONTENUM; +import static org.mozilla.javascript.ScriptableObject.PERMANENT; +import static org.mozilla.javascript.ScriptableObject.READONLY; +import static org.mozilla.javascript.Symbol.Kind.REGULAR; +import static org.mozilla.javascript.UniqueTag.NOT_FOUND; + import java.io.Serializable; import java.lang.reflect.Constructor; import java.lang.reflect.Field; @@ -69,17 +75,26 @@ public static BaseFunction typeErrorThrower() { /** Returns representation of the [[ThrowTypeError]] object. See ECMA 5 spec, 13.2.3 */ public static BaseFunction typeErrorThrower(Context cx) { - if (cx.typeErrorThrower == null) { - BaseFunction thrower = new ThrowTypeError(cx.topCallScope); - cx.typeErrorThrower = thrower; + return typeErrorThrower(cx.topCallScope); + } + + private static final SymbolKey TYPE_ERROR_THROWER = new SymbolKey("TypeErrorThrower", REGULAR); + + public static BaseFunction typeErrorThrower(VarScope scope) { + TopLevel top = ScriptableObject.getTopLevelScope(scope); + var thrower = top.get(TYPE_ERROR_THROWER, top); + if (thrower == NOT_FOUND) { + thrower = new ThrowTypeError(top); + top.defineProperty(TYPE_ERROR_THROWER, thrower, DONTENUM | READONLY | PERMANENT); } - return cx.typeErrorThrower; + return (BaseFunction) thrower; } static final class ThrowTypeError extends BaseFunction { private static final long serialVersionUID = -5891740962154902286L; ThrowTypeError(VarScope scope) { + super(scope); setPrototype(ScriptableObject.getFunctionPrototype(scope)); setAttributes("length", DONTENUM | PERMANENT | READONLY); @@ -102,7 +117,7 @@ private static > Slot removeWithoutChecking( } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { throwNotAllowed(); return null; } @@ -138,7 +153,7 @@ static class NoSuchMethodShim implements Callable { * @return the result of the call */ @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { Object[] nestedArgs = new Object[2]; nestedArgs[0] = methodName; @@ -207,7 +222,7 @@ public static TopLevel initSafeStandardObjects(Context cx, TopLevel scope, boole : new LegacyCacheFactory.Concurrent(); typeFactory.associate(scope); - LambdaConstructor function = BaseFunction.init(cx, scope, sealed); + JSFunction function = BaseFunction.init(cx, scope, sealed); JSFunction obj = NativeObject.init(cx, scope, sealed); ScriptableObject objectPrototype = (ScriptableObject) obj.getPrototypeProperty(); @@ -229,23 +244,23 @@ public static TopLevel initSafeStandardObjects(Context cx, TopLevel scope, boole // representation NativeArray.setMaximumInitialCapacity(200000); } - NativeString.init(scope, sealed); + NativeString.init(cx, scope, sealed); NativeBoolean.init(cx, scope, sealed); - NativeNumber.init(scope, sealed); + NativeNumber.init(cx, scope, sealed); NativeDate.init(cx, scope, sealed); new LazilyLoadedCtor<>(scope, "Math", sealed, true, NativeMath::init); new LazilyLoadedCtor<>(scope, "JSON", sealed, true, NativeJSON::init); - NativeScript.init(cx, scope, sealed); + NativeScript.init2(cx, scope, sealed); NativeIterator.init(cx, scope, sealed); // Also initializes NativeGenerator & ES6Generator - NativeArrayIterator.init(scope, sealed); - NativeStringIterator.init(scope, sealed); + NativeArrayIterator.init(cx, scope, sealed); + NativeStringIterator.init(cx, scope, sealed); registerRegExp(cx, scope, sealed); - NativeJavaObject.init(scope, sealed); - NativeJavaMap.init(scope, sealed); + NativeJavaObject.init(cx, scope, sealed); + NativeJavaMap.init(cx, scope, sealed); // define lazy-loaded properties using their class name // Depends on the old reflection-based lazy loading mechanism @@ -282,8 +297,6 @@ public static TopLevel initSafeStandardObjects(Context cx, TopLevel scope, boole if (cx.getLanguageVersion() >= Context.VERSION_ES6) { NativeSymbol.init(cx, scope, sealed); - NativeCollectionIterator.init(scope, NativeSet.ITERATOR_TAG, sealed); - NativeCollectionIterator.init(scope, NativeMap.ITERATOR_TAG, sealed); new LazilyLoadedCtor<>(scope, "Map", sealed, true, NativeMap::init); new LazilyLoadedCtor<>(scope, "Promise", sealed, true, NativePromise::init); new LazilyLoadedCtor<>(scope, "Set", sealed, true, NativeSet::init); @@ -302,7 +315,7 @@ public static TopLevel initSafeStandardObjects(Context cx, TopLevel scope, boole private static void registerRegExp(Context cx, TopLevel scope, boolean sealed) { RegExpProxy regExpProxy = getRegExpProxy(cx); if (regExpProxy != null) { - regExpProxy.register(scope, sealed); + regExpProxy.register(cx, scope, sealed); } } @@ -1641,6 +1654,17 @@ public static Function getExistingCtor(Context cx, VarScope scope, String constr throw Context.reportRuntimeErrorById("msg.not.ctor", constructorName); } + public static Function getExistingCtor(Context cx, VarScope scope, SymbolKey constructorName) { + Object ctorVal = ScriptableObject.getProperty(scope, constructorName); + if (ctorVal instanceof Function) { + return (Function) ctorVal; + } + if (ctorVal == Scriptable.NOT_FOUND) { + throw Context.reportRuntimeErrorById("msg.ctor.not.found", constructorName); + } + throw Context.reportRuntimeErrorById("msg.not.ctor", constructorName); + } + /** * Return -1L if str is not an index, or the index value as lower 32 bits of the result. Note * that the result needs to be cast to an int in order to produce the actual index, which may be @@ -2383,8 +2407,8 @@ private static Object nameOrFunction( break; } } - } else if (scope instanceof NativeCall) { - // NativeCall does not prototype chain and Scriptable.get + } else if (scope instanceof CatchScope || scope instanceof NativeCall) { + // Scopes do not have a prototype chain and Scriptable.get // can be called directly. result = scope.get(name, scope); if (result != Scriptable.NOT_FOUND) { @@ -2467,7 +2491,7 @@ private static LookupResult nameOrFunction( break; } } - } else if (scope instanceof NativeCall) { + } else if (scope instanceof CatchScope || scope instanceof NativeCall) { // NativeCall does not prototype chain and Scriptable.get // can be called directly. result = scope.get(name, scope); @@ -2530,18 +2554,24 @@ public static VarScope bind(Context cx, VarScope scope, String id) { childScopesChecks: if (parent != null) { // Check for possibly nested "with" scopes first - while (scope instanceof WithScope) { - Scriptable withObj = ((WithScope) scope).getObject(); - if (withObj instanceof XMLObject) { - XMLObject xmlObject = (XMLObject) withObj; - if (xmlObject.has(cx, id)) { - return new WithScope(scope.getParentScope(), xmlObject); - } - if (firstXMLScope == null) { - firstXMLScope = scope; + while (scope.isNestedScope()) { + if (scope instanceof WithScope) { + Scriptable withObj = ((WithScope) scope).getObject(); + if (withObj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject) withObj; + if (xmlObject.has(cx, id)) { + return new WithScope(scope.getParentScope(), xmlObject); + } + if (firstXMLScope == null) { + firstXMLScope = scope; + } + } else { + if (ScriptableObject.hasProperty(withObj, id)) { + return scope; + } } } else { - if (ScriptableObject.hasProperty(withObj, id)) { + if (scope.has(id, scope)) { return scope; } } @@ -2635,7 +2665,7 @@ public static Object setConst(VarScope bound, Object value, Context cx, String i * if a given property has already been enumerated. */ private static class IdEnumeration implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -8685189816346084720L; Scriptable obj; Object[] ids; HashSet used; @@ -2817,6 +2847,7 @@ public static Boolean enumNext(Object enumObj, Context cx) { private static Boolean enumNextInOrder(IdEnumeration enumObj, Context cx) { Object v = ScriptableObject.getProperty(enumObj.iterator, ES6Iterator.NEXT_METHOD); if (!(v instanceof Callable)) { + new Error(String.format("%s", v)).printStackTrace(); throw notFunctionError(enumObj.iterator, ES6Iterator.NEXT_METHOD); } Callable f = (Callable) v; @@ -3402,7 +3433,7 @@ public static boolean isIteratorDone(Context cx, Object result) { * times. The args array reference should not be stored in any object that can be GC-reachable * after this method returns. If this is necessary, store args.clone(), not args array itself. */ - public static Ref callRef(Callable function, Scriptable thisObj, Object[] args, Context cx) { + public static Ref callRef(Callable function, Object thisObj, Object[] args, Context cx) { if (function instanceof RefCallable) { RefCallable rfunction = (RefCallable) function; Ref ref = rfunction.refCall(cx, thisObj, args); @@ -3435,7 +3466,7 @@ public static Object callSpecial( Scriptable thisObj, Object[] args, VarScope scope, - Scriptable callerThis, + Object callerThis, int callType, String filename, int lineNumber, @@ -3474,7 +3505,7 @@ public static Object newSpecial( *

See Ecma 15.3.4.[34] */ public static Object applyOrCall( - boolean isApply, Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + boolean isApply, Context cx, VarScope scope, Object thisObj, Object[] args) { int L = args.length; Callable function = getCallable(thisObj); @@ -3550,14 +3581,16 @@ static Object[] getApplyArguments(Context cx, Object arg1) { } } - static Callable getCallable(Scriptable thisObj) { + static Callable getCallable(Object thisObj) { Callable function; if (thisObj instanceof Callable) { function = (Callable) thisObj; } else if (thisObj == null) { throw ScriptRuntime.notFunctionError(null, null); + } else if (!(thisObj instanceof Scriptable)) { + throw ScriptRuntime.notFunctionError(thisObj, null); } else { - Object value = thisObj.getDefaultValue(ScriptRuntime.FunctionClass); + Object value = ((Scriptable) thisObj).getDefaultValue(ScriptRuntime.FunctionClass); if (!(value instanceof Callable)) { throw ScriptRuntime.notFunctionError(value, thisObj); } @@ -4877,12 +4910,12 @@ public static TopLevel getTopCallScope(Context cx) { */ @Deprecated public static Object doTopCall( - Callable callable, Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + Callable callable, Context cx, VarScope scope, Object thisObj, Object[] args) { return doTopCall(callable, cx, scope, thisObj, args, cx.isStrictMode()); } @Deprecated - public static Object doTopCall(Script script, Context cx, VarScope scope, Scriptable thisObj) { + public static Object doTopCall(Script script, Context cx, VarScope scope, Object thisObj) { return doTopCall(script, cx, scope, thisObj, cx.isStrictMode()); } @@ -4890,7 +4923,7 @@ public static Object doTopCall( Callable callable, Context cx, VarScope scope, - Scriptable thisObj, + Object thisObj, Object[] args, boolean isTopLevelStrict) { if (scope == null) throw new IllegalArgumentException(); @@ -4917,11 +4950,7 @@ public static Object doTopCall( } public static Object doTopCall( - Script script, - Context cx, - VarScope scope, - Scriptable thisObj, - boolean isTopLevelStrict) { + Script script, Context cx, VarScope scope, Object thisObj, boolean isTopLevelStrict) { if (scope == null) throw new IllegalArgumentException(); if (cx.topCallScope != null) throw new IllegalStateException(); @@ -4986,11 +5015,7 @@ public static void addInstructionCount(Context cx, int instructionsToAdd) { } public static void initScript( - ScriptOrFn execObj, - Scriptable thisObj, - Context cx, - VarScope scope, - boolean evalScript) { + ScriptOrFn execObj, Object thisObj, Context cx, VarScope scope, boolean evalScript) { if (cx.topCallScope == null) throw new IllegalStateException(); var desc = execObj.getDescriptor(); @@ -5001,7 +5026,7 @@ public static void initScript( VarScope varScope = scope; // Never define any variables from var statements inside with // object. See bug 38590. - while (varScope instanceof WithScope) { + while (varScope.isNestedScope()) { varScope = varScope.getParentScope(); } @@ -5092,9 +5117,9 @@ static NativeCall findFunctionActivation(Context cx, Function f) { return null; } - public static Scriptable newCatchScope( + public static VarScope newCatchScope( Throwable t, - Scriptable lastCatchScope, + VarScope lastCatchScope, String exceptionName, Context cx, VarScope scope) { @@ -5112,8 +5137,7 @@ public static Scriptable newCatchScope( // the previous scope object if (lastCatchScope != null) { - NativeObject last = (NativeObject) lastCatchScope; - obj = last.getAssociatedValue(t); + obj = ((DeclarationScope) lastCatchScope).getAssociatedValue(t); if (obj == null) Kit.codeBug(); break getObj; } @@ -5200,26 +5224,26 @@ public static Scriptable newCatchScope( obj = errorObject; } - NativeObject catchScopeObject = new NativeObject(); + var catchScope = new CatchScope(scope); // See ECMA 12.4 if (exceptionName != null) { - catchScopeObject.defineProperty(exceptionName, obj, ScriptableObject.PERMANENT); + catchScope.defineProperty(exceptionName, obj, ScriptableObject.PERMANENT); } if (cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS) && isVisible(cx, t)) { // Add special Rhino object __exception__ defined in the catch // scope that can be used to retrieve the Java exception associated // with the JavaScript exception (to get stack trace info, etc.) - catchScopeObject.defineProperty( + catchScope.defineProperty( "__exception__", Context.javaToJS(t, scope), ScriptableObject.PERMANENT | ScriptableObject.DONTENUM); } if (cacheObj) { - catchScopeObject.associateValue(t, obj); + catchScope.associateValue(t, obj); } - return catchScopeObject; + return catchScope; } public static Scriptable wrapException(Throwable t, VarScope scope, Context cx) { @@ -5316,9 +5340,12 @@ public static VarScope enterWith(Object obj, Context cx, VarScope scope) { return new WithScope(scope, sobj); } - public static VarScope leaveWith(VarScope scope) { - WithScope nw = (WithScope) scope; - return nw.getParentScope(); + public static VarScope enterScope(VarScope scope) { + return new LocalScope(scope); + } + + public static VarScope leaveScope(VarScope scope) { + return scope.getParentScope(); } public static VarScope enterDotQuery(Object value, VarScope scope) { @@ -5364,9 +5391,22 @@ public static void setFunctionProtoAndParent( public static void setFunctionProtoAndParent( BaseFunction fn, Context cx, VarScope scope, boolean es6GeneratorFunction) { + setFunctionProtoAndParent(fn, cx, scope, es6GeneratorFunction, false); + } + + public static void setFunctionProtoAndParent( + BaseFunction fn, + Context cx, + VarScope scope, + boolean es6GeneratorFunction, + boolean isAsync) { fn.setParentScope(scope); - if (es6GeneratorFunction) { + if (es6GeneratorFunction && isAsync) { + fn.setPrototype(ScriptableObject.getAsyncGeneratorFunctionPrototype(scope)); + } else if (es6GeneratorFunction) { fn.setPrototype(ScriptableObject.getGeneratorFunctionPrototype(scope)); + } else if (isAsync) { + fn.setPrototype(ScriptableObject.getAsyncFunctionPrototype(scope)); } else { fn.setPrototype(ScriptableObject.getFunctionPrototype(scope)); } @@ -5393,10 +5433,33 @@ public static void setBuiltinProtoAndParent( public static void setBuiltinProtoAndParent( ScriptableObject obj, JSFunction f, Object nt, VarScope s, TopLevel.Builtins type) { - obj.setPrototype((Scriptable) f.getPrototypeProperty()); + obj.setPrototype(findPrototype(f, nt, type)); + obj.setParentScope(s); } + public static Scriptable findPrototype(JSFunction f, Object nt, TopLevel.Builtins type) { + Object proto; + if (nt instanceof JSFunction) { + proto = ((JSFunction) nt).getPrototypeProperty(); + } else if (nt instanceof Scriptable + && nt instanceof Function + && ((Function) nt).isConstructor()) { + var sobj = ((Scriptable) nt); + proto = sobj.get("prototype", sobj); + } else { + nt = f; + proto = ((JSFunction) nt).getPrototypeProperty(); + } + + if (proto instanceof Scriptable) { + return (Scriptable) proto; + } else { + TopLevel top = ScriptableObject.getTopLevelScope(((Function) nt).getDeclarationScope()); + return TopLevel.getBuiltinPrototype(top, type); + } + } + public static void initFunction( Context cx, VarScope scope, JSFunction function, int type, boolean fromEvalCode) { if (type == FunctionNode.FUNCTION_STATEMENT) { @@ -5417,11 +5480,18 @@ public static void initFunction( // Always put function expression statements into initial // activation object ignoring the with statement to follow // SpiderMonkey - while (scope instanceof WithScope) { + while (scope.isNestedScope()) { scope = scope.getParentScope(); } scope.put(name, scope, function); } + } else if (type == FunctionNode.FUNCTION_BLOCK_SCOPED) { + String name = function.getFunctionName(); + if (name != null && name.length() != 0) { + // Block-scoped function in strict mode: bind in the current + // (block) scope only, do not walk up to the activation object. + scope.put(name, scope, function); + } } else { throw Kit.codeBug(); } diff --git a/rhino/src/main/java/org/mozilla/javascript/ScriptRuntimeES6.java b/rhino/src/main/java/org/mozilla/javascript/ScriptRuntimeES6.java index 2d0c33b8357..a558ac5ebf8 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ScriptRuntimeES6.java +++ b/rhino/src/main/java/org/mozilla/javascript/ScriptRuntimeES6.java @@ -45,8 +45,7 @@ public static DescriptorInfo symbolSpecies( scope, "get [Symbol.species]", 0, - (Context lcx, VarScope lscope, Scriptable thisObj, Object[] args) -> - thisObj, + (Context lcx, VarScope lscope, Object thisObj, Object[] args) -> thisObj, false), ScriptableObject.NOT_FOUND, ScriptableObject.NOT_FOUND); diff --git a/rhino/src/main/java/org/mozilla/javascript/ScriptableObject.java b/rhino/src/main/java/org/mozilla/javascript/ScriptableObject.java index ef4bc22c3fa..881897262a9 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ScriptableObject.java +++ b/rhino/src/main/java/org/mozilla/javascript/ScriptableObject.java @@ -2180,6 +2180,16 @@ public static Scriptable getGeneratorFunctionPrototype(VarScope scope) { getTopLevelScope(scope), TopLevel.Builtins.GeneratorFunction); } + public static Scriptable getAsyncFunctionPrototype(VarScope scope) { + return TopLevel.getBuiltinPrototype( + getTopLevelScope(scope), TopLevel.Builtins.AsyncFunction); + } + + public static Scriptable getAsyncGeneratorFunctionPrototype(VarScope scope) { + return TopLevel.getBuiltinPrototype( + getTopLevelScope(scope), TopLevel.Builtins.AsyncGeneratorFunction); + } + public static Scriptable getArrayPrototype(VarScope scope) { return TopLevel.getBuiltinPrototype(getTopLevelScope(scope), TopLevel.Builtins.Array); } @@ -2214,6 +2224,24 @@ public static Scriptable getClassPrototype(VarScope scope, String className) { return null; } + public static Scriptable getClassPrototype(VarScope scope, Symbol className) { + scope = getTopLevelScope(scope); + Object ctor = getProperty(scope, className); + Object proto; + if (ctor instanceof BaseFunction) { + proto = ((BaseFunction) ctor).getPrototypeProperty(); + } else if (ctor instanceof Scriptable) { + Scriptable ctorObj = (Scriptable) ctor; + proto = ctorObj.get("prototype", ctorObj); + } else { + return null; + } + if (proto instanceof Scriptable) { + return (Scriptable) proto; + } + return null; + } + /** * Get the global scope. * @@ -2316,6 +2344,10 @@ public static Object getProperty(VarScope obj, String name) { return obj.get(name, obj); } + public static Object getProperty(VarScope obj, Symbol name) { + return obj.get(name, obj); + } + /** * Gets a named property from super, walking the super's prototype chain, but passing the * correct "this" to getter slots. diff --git a/rhino/src/main/java/org/mozilla/javascript/SecurityController.java b/rhino/src/main/java/org/mozilla/javascript/SecurityController.java index 64a519ef73c..eadcdcbfffb 100644 --- a/rhino/src/main/java/org/mozilla/javascript/SecurityController.java +++ b/rhino/src/main/java/org/mozilla/javascript/SecurityController.java @@ -135,14 +135,14 @@ public Object callWithDomain( Context cx, Callable callable, VarScope scope, - Scriptable thisObj, + Object thisObj, Object[] args) { return execWithDomain( cx, scope, new Script() { @Override - public Object exec(Context cx, VarScope scope, Scriptable thisObjIgnored) { + public Object exec(Context cx, VarScope scope, Object thisObjIgnored) { return callable.call(cx, scope, thisObj, args); } }, @@ -154,7 +154,7 @@ public Object callWithDomain( Context cx, Script script, VarScope scope, - Scriptable thisObj, + Object thisObj, Object[] args) { return execWithDomain(cx, scope, script, securityDomain); } diff --git a/rhino/src/main/java/org/mozilla/javascript/SlotMapOwner.java b/rhino/src/main/java/org/mozilla/javascript/SlotMapOwner.java index 89e6122eec5..2635be5e908 100644 --- a/rhino/src/main/java/org/mozilla/javascript/SlotMapOwner.java +++ b/rhino/src/main/java/org/mozilla/javascript/SlotMapOwner.java @@ -16,7 +16,6 @@ import java.util.Objects; public abstract class SlotMapOwner> implements PropHolder { - private static final long serialVersionUID = 1L; /** * Maximum size of an {@link EmbeddedSlotMap} before it is promoted to a {@link HashSlotMap}. diff --git a/rhino/src/main/java/org/mozilla/javascript/Synchronizer.java b/rhino/src/main/java/org/mozilla/javascript/Synchronizer.java index 7c8de98eb22..aa2c8b1a09f 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Synchronizer.java +++ b/rhino/src/main/java/org/mozilla/javascript/Synchronizer.java @@ -51,7 +51,7 @@ public Synchronizer(Scriptable obj, Object syncObject) { * @see org.mozilla.javascript.Function#call */ @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { Object sync = syncObject != null ? syncObject : thisObj; synchronized (sync instanceof Wrapper ? ((Wrapper) sync).unwrap() : sync) { return ((Function) obj).call(cx, scope, thisObj, args); diff --git a/rhino/src/main/java/org/mozilla/javascript/Token.java b/rhino/src/main/java/org/mozilla/javascript/Token.java index 6513f1bdc4d..7a821ddf794 100644 --- a/rhino/src/main/java/org/mozilla/javascript/Token.java +++ b/rhino/src/main/java/org/mozilla/javascript/Token.java @@ -41,8 +41,9 @@ public static enum CommentType { // Interpreter reuses the following as bytecodes FIRST_BYTECODE_TOKEN = EOL + 1, ENTERWITH = FIRST_BYTECODE_TOKEN, - LEAVEWITH = ENTERWITH + 1, - RETURN = LEAVEWITH + 1, + ENTER_SCOPE = ENTERWITH + 1, + LEAVE_SCOPE = ENTER_SCOPE + 1, + RETURN = LEAVE_SCOPE + 1, GOTO = RETURN + 1, IFEQ = GOTO + 1, IFNE = IFEQ + 1, @@ -132,10 +133,11 @@ public static enum CommentType { REF_NS_MEMBER = REF_MEMBER + 1, // Reference for x.ns::y, x..ns::y etc. REF_NAME = REF_NS_MEMBER + 1, // Reference for @y, @[y] etc. REF_NS_NAME = REF_NAME + 1, // Reference for ns::y, @ns::y@[y] etc. - BIGINT = REF_NS_NAME + 1; // ES2020 BigInt + BIGINT = REF_NS_NAME + 1, // ES2020 BigInt + NEW_TARGET = BIGINT + 1; // new.target meta-property // End of interpreter bytecodes - public static final int LAST_BYTECODE_TOKEN = BIGINT, + public static final int LAST_BYTECODE_TOKEN = NEW_TARGET, TRY = LAST_BYTECODE_TOKEN + 1, SEMI = TRY + 1, // semicolon LB = SEMI + 1, // left and right brackets @@ -209,7 +211,8 @@ public static enum CommentType { SETPROP_OP = USE_STACK + 1, // x.y op= something SETELEM_OP = SETPROP_OP + 1, // x[y] op= something LOCAL_BLOCK = SETELEM_OP + 1, - SET_REF_OP = LOCAL_BLOCK + 1, // *reference op= something + SCOPE_BLOCK = LOCAL_BLOCK + 1, + SET_REF_OP = SCOPE_BLOCK + 1, // *reference op= something // For XML support: DOTDOT = SET_REF_OP + 1, // member operator (..) @@ -230,7 +233,8 @@ public static enum CommentType { SETCONSTVAR = SETCONST + 1, ARRAYCOMP = SETCONSTVAR + 1, // array comprehension LETEXPR = ARRAYCOMP + 1, - WITHEXPR = LETEXPR + 1, + SCOPEEXPR = LETEXPR + 1, + WITHEXPR = SCOPEEXPR + 1, DEBUGGER = WITHEXPR + 1, COMMENT = DEBUGGER + 1, GENEXPR = COMMENT + 1, @@ -246,7 +250,8 @@ public static enum CommentType { NULLISH_COALESCING = DOTDOTDOT + 1, // nullish coalescing (??) QUESTION_DOT = NULLISH_COALESCING + 1, // optional chaining operator (?.) OBJECT_REST = QUESTION_DOT + 1, // ES6 object rest operation - LAST_TOKEN = OBJECT_REST + 1; + AWAIT = OBJECT_REST + 1, // ES2017 await expression + LAST_TOKEN = AWAIT + 1; /** * Returns a name for the token. If Rhino is compiled with certain hardcoded debugging flags in @@ -277,8 +282,10 @@ public static String typeToName(int token) { return "EOL"; case ENTERWITH: return "ENTERWITH"; - case LEAVEWITH: - return "LEAVEWITH"; + case ENTER_SCOPE: + return "ENTER_SCOPE"; + case LEAVE_SCOPE: + return "LEAVE_SCOPE"; case RETURN: return "RETURN"; case GOTO: @@ -579,6 +586,8 @@ public static String typeToName(int token) { return "SETELEM_OP"; case LOCAL_BLOCK: return "LOCAL_BLOCK"; + case SCOPE_BLOCK: + return "SCOPE_BLOCK"; case SET_REF_OP: return "SET_REF_OP"; case DOTDOT: @@ -599,6 +608,8 @@ public static String typeToName(int token) { return "TO_DOUBLE"; case OBJECT_REST: return "OBJECT_REST"; + case AWAIT: + return "AWAIT"; case GET: return "GET"; case SET: @@ -621,6 +632,8 @@ public static String typeToName(int token) { return "ARRAYCOMP"; case WITHEXPR: return "WITHEXPR"; + case SCOPEEXPR: + return "SCOPEEXPR"; case LETEXPR: return "LETEXPR"; case DEBUGGER: @@ -637,6 +650,8 @@ public static String typeToName(int token) { return "YIELD_STAR"; case BIGINT: return "BIGINT"; + case NEW_TARGET: + return "NEW_TARGET"; case TEMPLATE_LITERAL: return "TEMPLATE_LITERAL"; case STRING_CONCAT: diff --git a/rhino/src/main/java/org/mozilla/javascript/TokenStream.java b/rhino/src/main/java/org/mozilla/javascript/TokenStream.java index b7290479a7b..2f7012f77e2 100644 --- a/rhino/src/main/java/org/mozilla/javascript/TokenStream.java +++ b/rhino/src/main/java/org/mozilla/javascript/TokenStream.java @@ -396,7 +396,7 @@ private static int stringToKeywordForES(String name, boolean isStrict) { Id_yield = Token.YIELD, // 11.6.2.2 Future Reserved Words - Id_await = Token.RESERVED, + Id_await = Token.NAME, Id_enum = Token.RESERVED, // 11.6.2.2 NOTE Strict Future Reserved Words diff --git a/rhino/src/main/java/org/mozilla/javascript/TopLevel.java b/rhino/src/main/java/org/mozilla/javascript/TopLevel.java index 2754962cef7..325209847e9 100644 --- a/rhino/src/main/java/org/mozilla/javascript/TopLevel.java +++ b/rhino/src/main/java/org/mozilla/javascript/TopLevel.java @@ -60,11 +60,20 @@ public enum Builtins { Symbol, /** The built-in GeneratorFunction type. */ GeneratorFunction, + /** The built-in AsyncFunction type. */ + AsyncFunction, + /** The built-in AsyncGeneratorFunction type. */ + AsyncGeneratorFunction, /** The built-in BigInt type. */ BigInt, /** The built-in Promise type. */ Promise, Date, + Map, + Set, + WeakMap, + WeakSet, + Proxy, ArrayBuffer, Int8Array, Uint8Array, @@ -197,7 +206,22 @@ public void cacheBuiltins(boolean sealed) { // Handle weird situation of "GeneratorFunction" being a real constructor // which is never registered in the top-level scope ctors.put( - builtin, (BaseFunction) BaseFunction.initAsGeneratorFunction(this, sealed)); + builtin, + (BaseFunction) + BaseFunction.initAsGeneratorFunction( + Context.getCurrentContext(), this, sealed)); + } else if (builtin == Builtins.AsyncFunction) { + ctors.put( + builtin, + (BaseFunction) + BaseFunction.initAsAsyncFunction( + Context.getCurrentContext(), this, sealed)); + } else if (builtin == Builtins.AsyncGeneratorFunction) { + ctors.put( + builtin, + (BaseFunction) + BaseFunction.initAsAsyncGeneratorFunction( + Context.getCurrentContext(), this, sealed)); } } errors = new EnumMap<>(NativeErrors.class); @@ -240,16 +264,24 @@ public static Function getBuiltinCtor(Context cx, VarScope scope, Builtins type) } } // fall back to normal constructor lookup - String typeName; + Object typeName; if (type == Builtins.GeneratorFunction) { // GeneratorFunction isn't stored in scope with that name, but in case // we end up falling back to this value then we have to // look this up using a hidden name. typeName = BaseFunction.GENERATOR_FUNCTION_CLASS; + } else if (type == Builtins.AsyncFunction) { + typeName = BaseFunction.ASYNC_FUNCTION_CLASS; + } else if (type == Builtins.AsyncGeneratorFunction) { + typeName = BaseFunction.ASYNC_GENERATOR_FUNCTION_CLASS; } else { typeName = type.name(); } - return ScriptRuntime.getExistingCtor(cx, scope, typeName); + if (typeName instanceof String) { + return ScriptRuntime.getExistingCtor(cx, scope, (String) typeName); + } else { + return ScriptRuntime.getExistingCtor(cx, scope, (SymbolKey) typeName); + } } /** @@ -291,17 +323,24 @@ public static Scriptable getBuiltinPrototype(TopLevel scope, Builtins type) { return result; } - // fall back to normal prototype lookup - String typeName; + Object typeName; if (type == Builtins.GeneratorFunction) { // GeneratorFunction isn't stored in scope with that name, but in case // we end up falling back to this value then we have to // look this up using a hidden name. typeName = BaseFunction.GENERATOR_FUNCTION_CLASS; + } else if (type == Builtins.AsyncFunction) { + typeName = BaseFunction.ASYNC_FUNCTION_CLASS; + } else if (type == Builtins.AsyncGeneratorFunction) { + typeName = BaseFunction.ASYNC_GENERATOR_FUNCTION_CLASS; } else { typeName = type.name(); } - return ScriptableObject.getClassPrototype(scope, typeName); + if (typeName instanceof String) { + return ScriptableObject.getClassPrototype(scope, (String) typeName); + } else { + return ScriptableObject.getClassPrototype(scope, (SymbolKey) typeName); + } } /** diff --git a/rhino/src/main/java/org/mozilla/javascript/VarScope.java b/rhino/src/main/java/org/mozilla/javascript/VarScope.java index a2f86d0c5e5..172fc090a90 100644 --- a/rhino/src/main/java/org/mozilla/javascript/VarScope.java +++ b/rhino/src/main/java/org/mozilla/javascript/VarScope.java @@ -24,4 +24,8 @@ public interface VarScope extends PropHolder, ConstProperties { } public static class PositionComparator implements Comparator, Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 1551233591343412911L; /** * Sorts nodes by (relative) start position. The start positions are relative to their @@ -400,7 +400,7 @@ public boolean hasSideEffects() { case Token.INC: case Token.JSR: case Token.LABEL: - case Token.LEAVEWITH: + case Token.LEAVE_SCOPE: case Token.LET: case Token.LETEXPR: case Token.LOCAL_BLOCK: diff --git a/rhino/src/main/java/org/mozilla/javascript/ast/AwaitExpression.java b/rhino/src/main/java/org/mozilla/javascript/ast/AwaitExpression.java new file mode 100644 index 00000000000..04a02a836d9 --- /dev/null +++ b/rhino/src/main/java/org/mozilla/javascript/ast/AwaitExpression.java @@ -0,0 +1,68 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +package org.mozilla.javascript.ast; + +import org.mozilla.javascript.Token; + +/** + * AST node for an ES2017 {@code await} expression. Node type is {@link Token#AWAIT}. + * + * 

AwaitExpression :
+ *   await UnaryExpression
+ */ +public class AwaitExpression extends AstNode { + + private AstNode value; + + public AwaitExpression() { + type = Token.AWAIT; + } + + public AwaitExpression(int pos) { + super(pos); + type = Token.AWAIT; + } + + public AwaitExpression(int pos, int len) { + super(pos, len); + type = Token.AWAIT; + } + + public AwaitExpression(int pos, int len, AstNode value) { + super(pos, len); + type = Token.AWAIT; + setValue(value); + } + + /** Returns the awaited expression. */ + public AstNode getValue() { + return value; + } + + /** + * Sets the awaited expression, and sets its parent to this node. + * + * @param expr the expression to await + */ + public void setValue(AstNode expr) { + this.value = expr; + if (expr != null) expr.setParent(this); + } + + @Override + public String toSource(int depth) { + return value == null ? "await" : "await " + value.toSource(0); + } + + /** Visits this node, and if present, the awaited value. */ + @Override + public void visit(NodeVisitor v) { + if (v.visit(this) && value != null) { + value.visit(v); + } + } +} diff --git a/rhino/src/main/java/org/mozilla/javascript/ast/FunctionNode.java b/rhino/src/main/java/org/mozilla/javascript/ast/FunctionNode.java index d7eeaea0138..8a18162f949 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ast/FunctionNode.java +++ b/rhino/src/main/java/org/mozilla/javascript/ast/FunctionNode.java @@ -63,6 +63,7 @@ public class FunctionNode extends ScriptNode { public static final int FUNCTION_EXPRESSION = 2; public static final int FUNCTION_EXPRESSION_STATEMENT = 3; public static final int ARROW_FUNCTION = 4; + public static final int FUNCTION_BLOCK_SCOPED = 5; public static enum Form { FUNCTION, @@ -96,6 +97,12 @@ public void putDefaultParams(Object left, Object right) { defaultParams.add(right); } + @Override + public boolean hasDestructuring() { + return getProp(Node.DESTRUCTURING_PARAMS) != null + || ((destructuringRvalues != null) && !destructuringRvalues.isEmpty()); + } + @Override public List getDestructuringRvalues() { return destructuringRvalues; @@ -118,6 +125,7 @@ public void putDestructuringRvalues(Node left, Node right) { private boolean requiresArgumentObject; private boolean isGenerator; private boolean isES6Generator; + private boolean isAsync; private List generatorResumePoints; private Map liveLocals; private Node generatorParamInitBlock; // IR block for default parameters init in generators @@ -327,6 +335,15 @@ public void setIsES6Generator() { needsActivation = true; } + public boolean isAsync() { + return isAsync; + } + + public void setIsAsync() { + isAsync = true; + needsActivation = true; + } + @Override public boolean hasRestParameter() { return hasRestParameter; @@ -443,6 +460,9 @@ public String toSource(int depth) { boolean isArrow = functionType == ARROW_FUNCTION; if (!isMethod()) { sb.append(makeIndent(depth)); + if (isAsync) { + sb.append("async "); + } if (!isArrow) { sb.append("function"); } diff --git a/rhino/src/main/java/org/mozilla/javascript/ast/KeywordLiteral.java b/rhino/src/main/java/org/mozilla/javascript/ast/KeywordLiteral.java index 2cb92dc23dd..352a36d78d7 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ast/KeywordLiteral.java +++ b/rhino/src/main/java/org/mozilla/javascript/ast/KeywordLiteral.java @@ -10,9 +10,9 @@ /** * AST node for keyword literals: currently, {@code this}, {@code super}, {@code null}, {@code - * undefined}, {@code true}, {@code false}, and {@code debugger}. Node type is one of {@link - * Token#THIS}, {@link Token#SUPER}, {@link Token#NULL}, {@link Token#UNDEFINED}, {@link - * Token#TRUE}, {@link Token#FALSE}, or {@link Token#DEBUGGER}. + * undefined}, {@code true}, {@code false}, {@code debugger}, and {@code new.target}. Node type is + * one of {@link Token#THIS}, {@link Token#SUPER}, {@link Token#NULL}, {@link Token#UNDEFINED}, + * {@link Token#TRUE}, {@link Token#FALSE}, {@link Token#DEBUGGER}, or {@link Token#NEW_TARGET}. */ public class KeywordLiteral extends AstNode { @@ -49,7 +49,8 @@ public KeywordLiteral setType(int nodeType) { || nodeType == Token.UNDEFINED || nodeType == Token.TRUE || nodeType == Token.FALSE - || nodeType == Token.DEBUGGER)) + || nodeType == Token.DEBUGGER + || nodeType == Token.NEW_TARGET)) throw new IllegalArgumentException("Invalid node type: " + nodeType); type = nodeType; return this; @@ -86,6 +87,9 @@ public String toSource(int depth) { case Token.DEBUGGER: sb.append("debugger;\n"); break; + case Token.NEW_TARGET: + sb.append("new.target"); + break; default: throw new IllegalStateException("Invalid keyword literal type: " + getType()); } diff --git a/rhino/src/main/java/org/mozilla/javascript/ast/Scope.java b/rhino/src/main/java/org/mozilla/javascript/ast/Scope.java index b0d28b2bb31..a38ed22435b 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ast/Scope.java +++ b/rhino/src/main/java/org/mozilla/javascript/ast/Scope.java @@ -22,6 +22,11 @@ public class Scope extends Jump { // Use LinkedHashMap so that the iteration order is the insertion order protected Map symbolTable; + // Tracks var- and function-hoisted names that are declared anywhere within + // this scope's subtree, up to (and including) the enclosing function/script. + // Separate from symbolTable so block-scoped (let/const) declarations are + // never mixed in. + protected Map varSymbolTable; protected Scope parentScope; protected ScriptNode top; // current script or function scope @@ -97,6 +102,9 @@ public void replaceWith(Scope newScope) { if (symbolTable != null && !symbolTable.isEmpty()) { joinScopes(this, newScope); } + if (varSymbolTable != null && !varSymbolTable.isEmpty()) { + joinVarScopes(this, newScope); + } } /** Returns current script or function scope */ @@ -118,6 +126,14 @@ public static Scope splitScope(Scope scope) { Scope result = new Scope(scope.getPosition(), scope.getLength()); result.symbolTable = scope.symbolTable; scope.symbolTable = null; + if (result.symbolTable != null) { + for (Symbol sym : result.symbolTable.values()) { + sym.setContainingTable(result); + } + } + if (scope.varSymbolTable != null) { + result.varSymbolTable = new LinkedHashMap<>(scope.varSymbolTable); + } result.parent = scope.parent; result.setParentScope(scope.getParentScope()); scope.parent = result; @@ -125,6 +141,21 @@ public static Scope splitScope(Scope scope) { return result; } + /** + * Moves a single symbol from this scope to the destination scope. Unlike {@link #putSymbol}, + * this does not re-register the symbol with the top-level ScriptNode since it was already + * registered when first defined. + */ + public void moveSymbol(String name, Scope dest) { + if (symbolTable == null) return; + Symbol sym = symbolTable.remove(name); + if (sym != null) { + sym.setContainingTable(dest); + dest.ensureSymbolTable(); + dest.symbolTable.put(name, sym); + } + } + /** Copies all symbols from source scope to dest scope. */ public static void joinScopes(Scope source, Scope dest) { Map src = source.ensureSymbolTable(); @@ -139,6 +170,13 @@ public static void joinScopes(Scope source, Scope dest) { } } + /** Copies all var-hoisted symbol entries from source scope to dest scope. */ + public static void joinVarScopes(Scope source, Scope dest) { + if (source.varSymbolTable == null) return; + if (dest.varSymbolTable == null) dest.varSymbolTable = new LinkedHashMap<>(4); + dest.varSymbolTable.putAll(source.varSymbolTable); + } + /** * Returns the scope in which this name is defined * @@ -189,6 +227,36 @@ public void setSymbolTable(Map table) { symbolTable = table; } + /** + * Looks up a var-hoisted symbol recorded in this scope. + * + * @param name the symbol name + * @return the Symbol, or {@code null} if not found + */ + public Symbol getVarSymbol(String name) { + return varSymbolTable == null ? null : varSymbolTable.get(name); + } + + /** + * Records a var- or function-hoisted symbol in this scope's secondary index. Does not affect + * the master symbol list on the enclosing {@link ScriptNode}; that registration is handled by + * the normal {@link #putSymbol} call. + */ + public void putVarSymbol(Symbol symbol) { + if (symbol.getName() == null) throw new IllegalArgumentException("null symbol name"); + if (varSymbolTable == null) varSymbolTable = new LinkedHashMap<>(4); + varSymbolTable.put(symbol.getName(), symbol); + } + + /** + * Returns the var symbol table for this scope. + * + * @return the var symbol table. May be {@code null}. + */ + public Map getVarSymbolTable() { + return varSymbolTable; + } + private Map ensureSymbolTable() { if (symbolTable == null) { symbolTable = new LinkedHashMap<>(5); diff --git a/rhino/src/main/java/org/mozilla/javascript/ast/ScriptNode.java b/rhino/src/main/java/org/mozilla/javascript/ast/ScriptNode.java index f44e889732b..47e03a50ade 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ast/ScriptNode.java +++ b/rhino/src/main/java/org/mozilla/javascript/ast/ScriptNode.java @@ -256,6 +256,10 @@ public List getDestructuringRvalues() { return null; } + public boolean hasDestructuring() { + return false; + } + public boolean isShorthand() { return false; } diff --git a/rhino/src/main/java/org/mozilla/javascript/ast/Symbol.java b/rhino/src/main/java/org/mozilla/javascript/ast/Symbol.java index 2b5f5598ac7..8f97bba16b6 100644 --- a/rhino/src/main/java/org/mozilla/javascript/ast/Symbol.java +++ b/rhino/src/main/java/org/mozilla/javascript/ast/Symbol.java @@ -19,6 +19,9 @@ public class Symbol { private String name; private Node node; private Scope containingTable; + // For VAR (and pre-ES6 CONST/FUNCTION) symbols, the lexical scope in which + // the declaration actually appears, before hoisting to containingTable. + private Scope declaredScope; public Symbol() {} @@ -89,10 +92,32 @@ public void setContainingTable(Scope containingTable) { this.containingTable = containingTable; } + /** + * Returns the lexical scope in which this symbol was declared, or {@code null} if not set. For + * VAR symbols this is the block scope containing the declaration, which may differ from {@link + * #getContainingTable()} (the enclosing function/script to which the var is hoisted). + */ + public Scope getDeclaredScope() { + return declaredScope; + } + + /** Sets the lexical scope in which this symbol was declared. */ + public void setDeclaredScope(Scope declaredScope) { + this.declaredScope = declaredScope; + } + public String getDeclTypeName() { return Token.typeToName(declType); } + public boolean isDeclTypeLexical() { + return declType == Token.LET || declType == Token.CONST; + } + + public static boolean isDeclTypeLexical(int declType) { + return declType == Token.LET || declType == Token.CONST; + } + @Override public String toString() { StringBuilder result = new StringBuilder(); diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScope.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScope.java index 718fcace72b..16a8fc82313 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScope.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScope.java @@ -15,7 +15,7 @@ * URIs in order to resolve relative module IDs and check sandbox constraints. */ public class ModuleScope extends DeclarationScope { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -877901398709024429L; private final URI uri; private final URI base; diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScript.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScript.java index aa120a0536e..0d4ec07ea24 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScript.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/ModuleScript.java @@ -16,7 +16,7 @@ * @version $Id: ModuleScript.java,v 1.3 2011/04/07 20:26:11 hannes%helma.at Exp $ */ public class ModuleScript implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -8287890021565388770L; private final Script script; private final URI uri; private final URI base; diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/Require.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/Require.java index 4f681290388..32b3715ae68 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/Require.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/Require.java @@ -45,7 +45,7 @@ * @version $Id: Require.java,v 1.4 2011/04/07 20:26:11 hannes%helma.at Exp $ */ public class Require extends BaseFunction { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 5682218649242405574L; private final ModuleScriptProvider moduleScriptProvider; private final TopLevel nativeScope; private final Scriptable paths; @@ -87,6 +87,7 @@ public Require( Script preExec, Script postExec, boolean sandboxed) { + super(nativeScope); this.moduleScriptProvider = moduleScriptProvider; this.nativeScope = nativeScope; this.sandboxed = sandboxed; @@ -174,7 +175,7 @@ public void install(VarScope scope) { } @Override - public Object call(Context cx, VarScope scope, Scriptable thisObj, Object[] args) { + public Object call(Context cx, VarScope scope, Object thisObj, Object[] args) { if (args == null || args.length < 1) { throw ScriptRuntime.throwError(cx, scope, "require() needs one argument"); } diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/RequireBuilder.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/RequireBuilder.java index 543abae3631..2116804eb82 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/RequireBuilder.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/RequireBuilder.java @@ -20,7 +20,7 @@ * @version $Id: RequireBuilder.java,v 1.4 2011/04/07 20:26:11 hannes%helma.at Exp $ */ public class RequireBuilder implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 5244169608278369242L; private boolean sandboxed = true; private ModuleScriptProvider moduleScriptProvider; private Script preExec; diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/DefaultUrlConnectionExpiryCalculator.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/DefaultUrlConnectionExpiryCalculator.java index e118b03998a..2c93d98f245 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/DefaultUrlConnectionExpiryCalculator.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/DefaultUrlConnectionExpiryCalculator.java @@ -19,7 +19,7 @@ */ public class DefaultUrlConnectionExpiryCalculator implements UrlConnectionExpiryCalculator, Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 6649125723317726741L; private final long relativeExpiry; /** Creates a new default expiry calculator with one minute relative expiry. */ diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSource.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSource.java index 3c764c64479..e8fded89631 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSource.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSource.java @@ -31,7 +31,7 @@ * @version $Id: ModuleSource.java,v 1.3 2011/04/07 20:26:12 hannes%helma.at Exp $ */ public class ModuleSource implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 7183957145984428890L; private final Reader reader; private final Object securityDomain; private final URI uri; diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSourceProviderBase.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSourceProviderBase.java index f3f9982ee6d..c34e8913dc0 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSourceProviderBase.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ModuleSourceProviderBase.java @@ -26,7 +26,7 @@ * @version $Id: ModuleSourceProviderBase.java,v 1.3 2011/04/07 20:26:12 hannes%helma.at Exp $ */ public abstract class ModuleSourceProviderBase implements ModuleSourceProvider, Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = -5687971989835149396L; @Override public ModuleSource loadSource(String moduleId, Scriptable paths, Object validator) diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ParsedContentType.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ParsedContentType.java index 3d280b11e1e..a430e17e283 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ParsedContentType.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/ParsedContentType.java @@ -14,7 +14,7 @@ * @version $Id: ParsedContentType.java,v 1.3 2011/04/07 20:26:12 hannes%helma.at Exp $ */ public final class ParsedContentType implements Serializable { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 2660291075921848672L; private final String contentType; private final String encoding; diff --git a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/SoftCachingModuleScriptProvider.java b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/SoftCachingModuleScriptProvider.java index 70e2d8bd4c5..3560d2c0c8b 100644 --- a/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/SoftCachingModuleScriptProvider.java +++ b/rhino/src/main/java/org/mozilla/javascript/commonjs/module/provider/SoftCachingModuleScriptProvider.java @@ -30,7 +30,7 @@ * $ */ public class SoftCachingModuleScriptProvider extends CachingModuleScriptProviderBase { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 523398435792363456L; private transient ReferenceQueue