jdk-sandbox: comparison nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/Global.java

equal deleted inserted replaced

-:6c644cca3f3f
+:528cc67f1289
 // This special value is used to flag a lazily initialized global property.
 // This also serves as placeholder value used in place of a location property
 // (__FILE__, __DIR__, __LINE__)
 private static final Object LAZY_SENTINEL = new Object();
+private static final String PACKAGE_PREFIX = "jdk.nashorn.internal.objects.";
 private InvokeByName TO_STRING;
 private InvokeByName VALUE_OF;
 /**
 * Optimistic builtin names that require switchpoint invalidation
 /** ECMA 15.1.4.6 - Number constructor */
 @Property(name = "Number", attributes = Attribute.NOT_ENUMERABLE)
 public volatile Object number;
-/** ECMA 2016 19.4.1 - Symbol constructor */
-@Property(name = "Symbol", attributes = Attribute.NOT_ENUMERABLE)
-public volatile Object symbol;
 /**
 * Getter for ECMA 15.1.4.7 Date property
 *
 * @param self self reference
 final Global global = Global.instanceFrom(self);
 global.float64Array = value;
 }
 private volatile Object float64Array;
+/**
+* Getter for the Symbol property.
+*
+* @param self self reference
+* @return  the value of the Symbol property
+*/
+@Getter(name = "Symbol", attributes = Attribute.NOT_ENUMERABLE)
+public static Object getSymbol(final Object self) {
+final Global global = Global.instanceFrom(self);
+if (global.symbol == LAZY_SENTINEL) {
+global.symbol = global.getBuiltinSymbol();
+}
+return global.symbol;
+}
+/**
+* Setter for the Symbol property.
+*
+* @param self self reference
+* @param value value of the Symbol property
+*/
+@Setter(name = "Symbol", attributes = Attribute.NOT_ENUMERABLE)
+public static void setSymbol(final Object self, final Object value) {
+Global.instanceFrom(self).symbol = value;
+}
+private volatile Object symbol;
+/**
+* Getter for the Map property.
+*
+* @param self self reference
+* @return  the value of the Map property
+*/
+@Getter(name = "Map", attributes = Attribute.NOT_ENUMERABLE)
+public static Object getMap(final Object self) {
+final Global global = Global.instanceFrom(self);
+if (global.map == LAZY_SENTINEL) {
+global.map = global.getBuiltinMap();
+}
+return global.map;
+}
+/**
+* Setter for the Map property.
+*
+* @param self self reference
+* @param value value of the Map property
+*/
+@Setter(name = "Map", attributes = Attribute.NOT_ENUMERABLE)
+public static void setMap(final Object self, final Object value) {
+Global.instanceFrom(self).map = value;
+}
+private volatile Object map;
+/**
+* Getter for the WeakMap property.
+*
+* @param self self reference
+* @return  the value of the WeakMap property
+*/
+@Getter(name = "WeakMap", attributes = Attribute.NOT_ENUMERABLE)
+public static Object getWeakMap(final Object self) {
+final Global global = Global.instanceFrom(self);
+if (global.weakMap == LAZY_SENTINEL) {
+global.weakMap = global.getBuiltinWeakMap();
+}
+return global.weakMap;
+}
+/**
+* Setter for the WeakMap property.
+*
+* @param self self reference
+* @param value value of the WeakMap property
+*/
+@Setter(name = "WeakMap", attributes = Attribute.NOT_ENUMERABLE)
+public static void setWeakMap(final Object self, final Object value) {
+Global.instanceFrom(self).weakMap = value;
+}
+private volatile Object weakMap;
+/**
+* Getter for the Set property.
+*
+* @param self self reference
+* @return  the value of the Set property
+*/
+@Getter(name = "Set", attributes = Attribute.NOT_ENUMERABLE)
+public static Object getSet(final Object self) {
+final Global global = Global.instanceFrom(self);
+if (global.set == LAZY_SENTINEL) {
+global.set = global.getBuiltinSet();
+}
+return global.set;
+}
+/**
+* Setter for the Set property.
+*
+* @param self self reference
+* @param value value of the Set property
+*/
+@Setter(name = "Set", attributes = Attribute.NOT_ENUMERABLE)
+public static void setSet(final Object self, final Object value) {
+Global.instanceFrom(self).set = value;
+}
+private volatile Object set;
+/**
+* Getter for the WeakSet property.
+*
+* @param self self reference
+* @return  the value of the WeakSet property
+*/
+@Getter(name = "WeakSet", attributes = Attribute.NOT_ENUMERABLE)
+public static Object getWeakSet(final Object self) {
+final Global global = Global.instanceFrom(self);
+if (global.weakSet == LAZY_SENTINEL) {
+global.weakSet = global.getBuiltinWeakSet();
+}
+return global.weakSet;
+}
+/**
+* Setter for the WeakSet property.
+*
+* @param self self reference
+* @param value value of the WeakSet property
+*/
+@Setter(name = "WeakSet", attributes = Attribute.NOT_ENUMERABLE)
+public static void setWeakSet(final Object self, final Object value) {
+Global.instanceFrom(self).weakSet = value;
+}
+private volatile Object weakSet;
 /** Nashorn extension: Java access - global.Packages */
 @Property(name = "Packages", attributes = Attribute.NOT_ENUMERABLE)
 public volatile Object packages;
 private ScriptFunction builtinInt32Array;
 private ScriptFunction builtinUint32Array;
 private ScriptFunction builtinFloat32Array;
 private ScriptFunction builtinFloat64Array;
 private ScriptFunction builtinSymbol;
+private ScriptFunction builtinMap;
+private ScriptFunction builtinWeakMap;
+private ScriptFunction builtinSet;
+private ScriptFunction builtinWeakSet;
+private ScriptObject   builtinIteratorPrototype;
+private ScriptObject   builtinMapIteratorPrototype;
+private ScriptObject   builtinSetIteratorPrototype;
+private ScriptObject   builtinArrayIteratorPrototype;
+private ScriptObject   builtinStringIteratorPrototype;
 /*
 * ECMA section 13.2.3 The [[ThrowTypeError]] Function Object
 */
 private ScriptFunction typeErrorThrower;
 ScriptObject getJSAdapterPrototype() {
 return ScriptFunction.getPrototype(getBuiltinJSAdapter());
 }
 ScriptObject getSymbolPrototype() {
-return ScriptFunction.getPrototype(builtinSymbol);
+return ScriptFunction.getPrototype(getBuiltinSymbol());
+}
+ScriptObject getMapPrototype() {
+return ScriptFunction.getPrototype(getBuiltinMap());
+}
+ScriptObject getWeakMapPrototype() {
+return ScriptFunction.getPrototype(getBuiltinWeakMap());
+}
+ScriptObject getSetPrototype() {
+return ScriptFunction.getPrototype(getBuiltinSet());
+}
+ScriptObject getWeakSetPrototype() {
+return ScriptFunction.getPrototype(getBuiltinWeakSet());
+}
+ScriptObject getIteratorPrototype() {
+if (builtinIteratorPrototype == null) {
+builtinIteratorPrototype = initPrototype("AbstractIterator", getObjectPrototype());
+}
+return builtinIteratorPrototype;
+}
+ScriptObject getMapIteratorPrototype() {
+if (builtinMapIteratorPrototype == null) {
+builtinMapIteratorPrototype = initPrototype("MapIterator", getIteratorPrototype());
+}
+return builtinMapIteratorPrototype;
+}
+ScriptObject getSetIteratorPrototype() {
+if (builtinSetIteratorPrototype == null) {
+builtinSetIteratorPrototype = initPrototype("SetIterator", getIteratorPrototype());
+}
+return builtinSetIteratorPrototype;
+}
+ScriptObject getArrayIteratorPrototype() {
+if (builtinArrayIteratorPrototype == null) {
+builtinArrayIteratorPrototype = initPrototype("ArrayIterator", getIteratorPrototype());
+}
+return builtinArrayIteratorPrototype;
+}
+ScriptObject getStringIteratorPrototype() {
+if (builtinStringIteratorPrototype == null) {
+builtinStringIteratorPrototype = initPrototype("StringIterator", getIteratorPrototype());
+}
+return builtinStringIteratorPrototype;
 }
 private synchronized ScriptFunction getBuiltinArrayBuffer() {
 if (this.builtinArrayBuffer == null) {
 this.builtinArrayBuffer = initConstructorAndSwitchPoint("ArrayBuffer", ScriptFunction.class);
 private synchronized ScriptFunction getBuiltinURIError() {
 if (this.builtinURIError == null) {
 this.builtinURIError = initErrorSubtype("URIError", getErrorPrototype());
 }
 return this.builtinURIError;
+}
+private synchronized ScriptFunction getBuiltinSymbol() {
+if (this.builtinSymbol == null) {
+this.builtinSymbol = initConstructorAndSwitchPoint("Symbol", ScriptFunction.class);
+}
+return this.builtinSymbol;
+}
+private synchronized ScriptFunction getBuiltinMap() {
+if (this.builtinMap == null) {
+this.builtinMap = initConstructorAndSwitchPoint("Map", ScriptFunction.class);
+}
+return this.builtinMap;
+}
+private synchronized ScriptFunction getBuiltinWeakMap() {
+if (this.builtinWeakMap == null) {
+this.builtinWeakMap = initConstructorAndSwitchPoint("WeakMap", ScriptFunction.class);
+}
+return this.builtinWeakMap;
+}
+private synchronized ScriptFunction getBuiltinSet() {
+if (this.builtinSet == null) {
+this.builtinSet = initConstructorAndSwitchPoint("Set", ScriptFunction.class);
+}
+return this.builtinSet;
+}
+private synchronized ScriptFunction getBuiltinWeakSet() {
+if (this.builtinWeakSet == null) {
+this.builtinWeakSet = initConstructorAndSwitchPoint("WeakSet", ScriptFunction.class);
+}
+return this.builtinWeakSet;
 }
 @Override
 public String getClassName() {
 return "global";
 this.builtinBoolean   = initConstructorAndSwitchPoint("Boolean", ScriptFunction.class);
 this.builtinNumber    = initConstructorAndSwitchPoint("Number", ScriptFunction.class);
 this.builtinString    = initConstructorAndSwitchPoint("String", ScriptFunction.class);
 this.builtinMath      = initConstructorAndSwitchPoint("Math", ScriptObject.class);
-if (env._es6) {
-this.builtinSymbol = initConstructorAndSwitchPoint("Symbol", ScriptFunction.class);
-} else {
-// We need to manually delete nasgen-generated properties we don't want
-this.delete("Symbol", false);
-this.builtinObject.delete("getOwnPropertySymbols", false);
-}
 // initialize String.prototype.length to 0
 // add String.prototype.length
 final ScriptObject stringPrototype = getStringPrototype();
 stringPrototype.addOwnProperty("length", Attribute.NON_ENUMERABLE_CONSTANT, 0.0);
 // set isArray flag on Array.prototype
 final ScriptObject arrayPrototype = getArrayPrototype();
 arrayPrototype.setIsArray();
+if (env._es6) {
+this.symbol   = LAZY_SENTINEL;
+this.map      = LAZY_SENTINEL;
+this.weakMap  = LAZY_SENTINEL;
+this.set      = LAZY_SENTINEL;
+this.weakSet  = LAZY_SENTINEL;
+} else {
+// We need to manually delete nasgen-generated properties we don't want
+this.delete("Symbol", false);
+this.delete("Map", false);
+this.delete("WeakMap", false);
+this.delete("Set", false);
+this.delete("WeakSet", false);
+builtinObject.delete("getOwnPropertySymbols", false);
+arrayPrototype.delete("entries", false);
+arrayPrototype.delete("keys", false);
+arrayPrototype.delete("values", false);
+}
 // Error stuff
 initErrorObjects();
 // java access
 this.packages          = this.builtinPackages;
 this.referenceError    = this.builtinReferenceError;
 this.string            = this.builtinString;
 this.syntaxError       = this.builtinSyntaxError;
 this.typeError         = this.builtinTypeError;
-this.symbol            = this.builtinSymbol;
 }
 private void initDebug() {
 this.addOwnProperty("Debug", Attribute.NOT_ENUMERABLE, initConstructor("Debug", ScriptObject.class));
 }
 }
 private <T extends ScriptObject> T initConstructor(final String name, final Class<T> clazz) {
 try {
 // Assuming class name pattern for built-in JS constructors.
-final StringBuilder sb = new StringBuilder("jdk.nashorn.internal.objects.");
+final StringBuilder sb = new StringBuilder(PACKAGE_PREFIX);
 sb.append("Native");
 sb.append(name);
 sb.append("$Constructor");
 res.setInitialProto(getObjectPrototype());
 }
 res.setIsBuiltin();
+return res;
+} catch (final ClassNotFoundException | InstantiationException | IllegalAccessException e) {
+throw new RuntimeException(e);
+}
+}
+private ScriptObject initPrototype(final String name, final ScriptObject prototype) {
+try {
+// Assuming class name pattern for JS prototypes
+final String className = PACKAGE_PREFIX + name + "$Prototype";
+final Class<?> funcClass = Class.forName(className);
+final ScriptObject res = (ScriptObject) funcClass.newInstance();
+res.setIsBuiltin();
+res.setInitialProto(prototype);
 return res;
 } catch (final ClassNotFoundException | InstantiationException | IllegalAccessException e) {
 throw new RuntimeException(e);
 }
 }

changeset 36023	528cc67f1289
parent 35794	049749629dbe
child 36479	560761a8e879