--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/NativeJavaPackage.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.runtime;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import jdk.dynalink.CallSiteDescriptor;
+import jdk.dynalink.beans.BeansLinker;
+import jdk.dynalink.beans.StaticClass;
+import jdk.dynalink.linker.GuardedInvocation;
+import jdk.dynalink.linker.LinkRequest;
+import jdk.dynalink.linker.support.Guards;
+import jdk.nashorn.internal.lookup.MethodHandleFactory;
+import jdk.nashorn.internal.lookup.MethodHandleFunctionality;
+import jdk.nashorn.internal.objects.annotations.Attribute;
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
+
+/**
+ * An object that exposes Java packages and classes as its properties. Packages are exposed as objects that have further
+ * sub-packages and classes as their properties. Normally, three instances of this class are exposed as built-in objects
+ * in Nashorn: {@code "Packages"}, {@code "java"}, and {@code "javax"}. Typical usages are:
+ * <pre>
+ * var list = new java.util.ArrayList()
+ * var sprocket = new Packages.com.acme.Sprocket()
+ * </pre>
+ * or you can store the type objects in a variable for later reuse:
+ * <pre>
+ * var ArrayList = java.util.ArrayList
+ * var list = new ArrayList
+ * </pre>
+ * You can also use {@link jdk.nashorn.internal.objects.NativeJava#type(Object, Object)} to access Java classes. These two statements are mostly
+ * equivalent:
+ * <pre>
+ * var listType1 = java.util.ArrayList
+ * var listType2 = Java.type("java.util.ArrayList")
+ * </pre>
+ * The difference is that {@code Java.type()} will throw an error if the class does not exist, while the first
+ * expression will return an empty object, as it must treat all non-existent classes as potentially being further
+ * subpackages. As such, {@code Java.type()} has the potential to catch typos earlier. A further difference is that
+ * {@code Java.type()} doesn't recognize {@code .} (dot) as the separator between outer class name and inner class name,
+ * it only recognizes the dollar sign. These are equivalent:
+ * <pre>
+ * var ftype1 = java.awt.geom.Arc2D$Float
+ * var ftype2 = java.awt.geom.Arc2D.Float
+ * var ftype3 = Java.asType("java.awt.geom.Arc2D$Float")
+ * var ftype4 = Java.asType("java.awt.geom.Arc2D").Float
+ * </pre>
+ */
+public final class NativeJavaPackage extends ScriptObject {
+ private static final MethodHandleFunctionality MH = MethodHandleFactory.getFunctionality();
+ private static final MethodHandle CLASS_NOT_FOUND = findOwnMH("classNotFound", Void.TYPE, NativeJavaPackage.class);
+ private static final MethodHandle TYPE_GUARD = Guards.getClassGuard(NativeJavaPackage.class);
+
+ /** Full name of package (includes path.) */
+ private final String name;
+
+ /**
+ * Public constructor to be accessible from {@link jdk.nashorn.internal.objects.Global}
+ * @param name package name
+ * @param proto proto
+ */
+ public NativeJavaPackage(final String name, final ScriptObject proto) {
+ super(proto, null);
+ // defense-in-path, check here for sensitive packages
+ Context.checkPackageAccess(name);
+ this.name = name;
+ }
+
+ @Override
+ public String getClassName() {
+ return "JavaPackage";
+ }
+
+ @Override
+ public boolean equals(final Object other) {
+ if (other instanceof NativeJavaPackage) {
+ return name.equals(((NativeJavaPackage)other).name);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return name == null ? 0 : name.hashCode();
+ }
+
+ /**
+ * Get the full name of the package
+ * @return the name
+ */
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public String safeToString() {
+ return toString();
+ }
+
+ @Override
+ public String toString() {
+ return "[JavaPackage " + name + "]";
+ }
+
+ @Override
+ public Object getDefaultValue(final Class<?> hint) {
+ if (hint == String.class) {
+ return toString();
+ }
+
+ return super.getDefaultValue(hint);
+ }
+
+ @Override
+ protected GuardedInvocation findNewMethod(final CallSiteDescriptor desc, final LinkRequest request) {
+ return createClassNotFoundInvocation(desc);
+ }
+
+ @Override
+ protected GuardedInvocation findCallMethod(final CallSiteDescriptor desc, final LinkRequest request) {
+ return createClassNotFoundInvocation(desc);
+ }
+
+ private static GuardedInvocation createClassNotFoundInvocation(final CallSiteDescriptor desc) {
+ // If NativeJavaPackage is invoked either as a constructor or as a function, throw a ClassNotFoundException as
+ // we can assume the user attempted to instantiate a non-existent class.
+ final MethodType type = desc.getMethodType();
+ return new GuardedInvocation(
+ MH.dropArguments(CLASS_NOT_FOUND, 1, type.parameterList().subList(1, type.parameterCount())),
+ type.parameterType(0) == NativeJavaPackage.class ? null : TYPE_GUARD);
+ }
+
+ @SuppressWarnings("unused")
+ private static void classNotFound(final NativeJavaPackage pkg) throws ClassNotFoundException {
+ throw new ClassNotFoundException(pkg.name);
+ }
+
+ /**
+ * "No such property" call placeholder.
+ *
+ * This can never be called as we override {@link ScriptObject#noSuchProperty}. We do declare it here as it's a signal
+ * to {@link WithObject} that it's worth trying doing a {@code noSuchProperty} on this object.
+ *
+ * @param self self reference
+ * @param name property name
+ * @return never returns
+ */
+ @Function(attributes = Attribute.NOT_ENUMERABLE)
+ public static Object __noSuchProperty__(final Object self, final Object name) {
+ throw new AssertionError("__noSuchProperty__ placeholder called");
+ }
+
+ /**
+ * "No such method call" placeholder
+ *
+ * This can never be called as we override {@link ScriptObject#noSuchMethod}. We do declare it here as it's a signal
+ * to {@link WithObject} that it's worth trying doing a noSuchProperty on this object.
+ *
+ * @param self self reference
+ * @param args arguments to method
+ * @return never returns
+ */
+ @Function(attributes = Attribute.NOT_ENUMERABLE)
+ public static Object __noSuchMethod__(final Object self, final Object... args) {
+ throw new AssertionError("__noSuchMethod__ placeholder called");
+ }
+
+ /**
+ * Handle creation of new attribute.
+ * @param desc the call site descriptor
+ * @param request the link request
+ * @return Link to be invoked at call site.
+ */
+ @Override
+ public GuardedInvocation noSuchProperty(final CallSiteDescriptor desc, final LinkRequest request) {
+ final String propertyName = NashornCallSiteDescriptor.getOperand(desc);
+ createProperty(propertyName);
+ return super.lookup(desc, request);
+ }
+
+ @Override
+ protected Object invokeNoSuchProperty(final Object key, final boolean isScope, final int programPoint) {
+ if (!(key instanceof String)) {
+ return super.invokeNoSuchProperty(key, isScope, programPoint);
+ }
+ final Object retval = createProperty((String) key);
+ if (isValid(programPoint)) {
+ throw new UnwarrantedOptimismException(retval, programPoint);
+ }
+ return retval;
+ }
+
+ @Override
+ public GuardedInvocation noSuchMethod(final CallSiteDescriptor desc, final LinkRequest request) {
+ return noSuchProperty(desc, request);
+ }
+
+ private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
+ return MH.findStatic(MethodHandles.lookup(), NativeJavaPackage.class, name, MH.type(rtype, types));
+ }
+
+ private Object createProperty(final String propertyName) {
+ final String fullName = name.isEmpty() ? propertyName : name + "." + propertyName;
+ final Context context = Context.getContextTrusted();
+
+ Class<?> javaClass = null;
+ try {
+ javaClass = context.findClass(fullName);
+ } catch (final NoClassDefFoundError | ClassNotFoundException e) {
+ //ignored
+ }
+
+ // Check for explicit constructor signature use
+ // Example: new (java.awt["Color(int, int,int)"])(2, 3, 4);
+ final int openBrace = propertyName.indexOf('(');
+ final int closeBrace = propertyName.lastIndexOf(')');
+ if (openBrace != -1 || closeBrace != -1) {
+ final int lastChar = propertyName.length() - 1;
+ if (openBrace == -1 || closeBrace != lastChar) {
+ throw typeError("improper.constructor.signature", propertyName);
+ }
+
+ // get the class name and try to load it
+ final String className = name + "." + propertyName.substring(0, openBrace);
+ try {
+ javaClass = context.findClass(className);
+ } catch (final NoClassDefFoundError | ClassNotFoundException e) {
+ throw typeError(e, "no.such.java.class", className);
+ }
+
+ // try to find a matching constructor
+ final Object constructor = BeansLinker.getConstructorMethod(
+ javaClass, propertyName.substring(openBrace + 1, lastChar));
+ if (constructor != null) {
+ set(propertyName, constructor, 0);
+ return constructor;
+ }
+ // we didn't find a matching constructor!
+ throw typeError("no.such.java.constructor", propertyName);
+ }
+
+ final Object propertyValue;
+ if (javaClass == null) {
+ propertyValue = new NativeJavaPackage(fullName, getProto());
+ } else {
+ propertyValue = StaticClass.forClass(javaClass);
+ }
+
+ set(propertyName, propertyValue, 0);
+ return propertyValue;
+ }
+}