diff --git a/jdk/.hgtags b/jdk/.hgtags index c954b5404d0..f4217d62903 100644 --- a/jdk/.hgtags +++ b/jdk/.hgtags @@ -410,3 +410,5 @@ f6bf027e88e9a4dd19f721001a7af00157af42c4 jdk-9+162 a7942c3b1e59495dbf51dc7c41aab355fcd253d7 jdk-9+165 5d2b48f1f0a322aca719b49ff02ab421705bffc7 jdk-9+166 7828aedcb525df40b7c8122bcc3f997c75ebaf7f jdk-9+167 +e78da9db6299b3fcba49300d52e2359e82fdd218 jdk-9+168 +177436a54ca13730ffc725a6e5dbfcd9486f3da3 jdk-9+169 diff --git a/jdk/make/CompileDemos.gmk b/jdk/make/CompileDemos.gmk index 336a2538e83..5b093935cd7 100644 --- a/jdk/make/CompileDemos.gmk +++ b/jdk/make/CompileDemos.gmk @@ -291,9 +291,21 @@ endif ################################################################################ +ifneq ($(filter images, $(MAKECMDGOALS)), ) + $(eval $(call SetupCopyFiles, COPY_TO_TEST_IMAGE, \ + SRC := $(SUPPORT_OUTPUTDIR)/demos/image, \ + DEST := $(TEST_IMAGE_DIR)/jdk/demos, \ + FILES := $(call DoubleDollar, $(call CacheFind, $(SUPPORT_OUTPUTDIR)/demos/image)), \ + )) + + IMAGES_TARGETS := $(COPY_TO_TEST_IMAGE) +endif + +################################################################################ # Hook to include the corresponding custom file, if present. $(eval $(call IncludeCustomExtension, jdk, CompileDemos.gmk)) all: $(TARGETS) +images: $(IMAGES_TARGETS) .PHONY: all diff --git a/jdk/make/data/docs-resources/specs/resources/jdk-default.css b/jdk/make/data/docs-resources/specs/resources/jdk-default.css new file mode 100644 index 00000000000..eea78ea539d --- /dev/null +++ b/jdk/make/data/docs-resources/specs/resources/jdk-default.css @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2017, 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. + */ + +body { + margin: 2em 2em; + font-family: DejaVu Sans, Bitstream Vera Sans, Luxi Sans, Verdana, Arial, Helvetica; + font-size: 10pt; + line-height: 1.4; +} + +pre, code, tt { + font-family: DejaVu Sans Mono, Bitstream Vera Sans Mono, Luxi Mono, + Courier New, monospace; +} + +blockquote { + margin: 1.5ex 0em 1.5ex 2em; +} + +p { + padding: 0pt; + margin: 1ex 0em; +} + +p:first-child, pre:first-child { margin-top: 0pt; } + +h1 { + font-weight: bold; + padding: 0pt; + margin: 2ex .5ex 1ex 0pt; +} + +h1:first-child, h2:first-child { + margin-top: 0ex; +} + +h2 { + font-weight: bold; + padding: 0pt; + margin: 2ex 0pt 1ex 0pt; +} + +h3 { + font-weight: bold; + padding: 0pt; + margin: 1.5ex 0pt 1ex 0pt; +} + +h4 { + font-weight: bold; + padding: 0pt; + margin: 1.5ex 0pt 1ex 0pt; +} + +a:link { + color: #437291; +} + +a:visited { + color: #666666; +} + +a[href]:hover { + color: #e76f00; +} + +a img { + border-width: 0px; +} + +img { + background: white; +} + +table { + border-collapse: collapse; + margin-left: 15px; + margin-right: 15px; +} + +th, td { + padding: 3px; + vertical-align: top; +} + +table, th, td { + border: 1px solid black; +} + +caption { + text-align: left; + font-style: italic; + text-indent: 15px; + margin-bottom:10px; +} + +tr:nth-child(even) { + background: #DDD; +} + +tr:nth-child(odd) { + background: #FFF; +} + +th { + background: #DDF; +} diff --git a/jdk/make/mapfiles/libinstrument/mapfile-vers b/jdk/make/mapfiles/libinstrument/mapfile-vers index 748670139bd..c51a8af2dc7 100644 --- a/jdk/make/mapfiles/libinstrument/mapfile-vers +++ b/jdk/make/mapfiles/libinstrument/mapfile-vers @@ -39,6 +39,7 @@ SUNWprivate_1.1 { Java_sun_instrument_InstrumentationImpl_getObjectSize0; Java_sun_instrument_InstrumentationImpl_appendToClassLoaderSearch0; Java_sun_instrument_InstrumentationImpl_setNativeMethodPrefixes; + Java_sun_instrument_InstrumentationImpl_loadAgent0; local: *; }; diff --git a/jdk/src/java.base/macosx/native/libnet/DefaultProxySelector.c b/jdk/src/java.base/macosx/native/libnet/DefaultProxySelector.c index ab6f465da40..aa91f3012b2 100644 --- a/jdk/src/java.base/macosx/native/libnet/DefaultProxySelector.c +++ b/jdk/src/java.base/macosx/native/libnet/DefaultProxySelector.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2017 SAP SE. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * diff --git a/jdk/src/java.base/share/classes/com/sun/crypto/provider/GCTR.java b/jdk/src/java.base/share/classes/com/sun/crypto/provider/GCTR.java index 6a394e448d1..ffa681c6a2b 100644 --- a/jdk/src/java.base/share/classes/com/sun/crypto/provider/GCTR.java +++ b/jdk/src/java.base/share/classes/com/sun/crypto/provider/GCTR.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2017 Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2017, 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 diff --git a/jdk/src/java.base/share/classes/com/sun/java/util/jar/pack/PropMap.java b/jdk/src/java.base/share/classes/com/sun/java/util/jar/pack/PropMap.java index 3d54b911492..4a1d4be9362 100644 --- a/jdk/src/java.base/share/classes/com/sun/java/util/jar/pack/PropMap.java +++ b/jdk/src/java.base/share/classes/com/sun/java/util/jar/pack/PropMap.java @@ -29,6 +29,8 @@ import java.io.IOException; import java.io.InputStream; import java.io.PrintStream; import java.io.PrintWriter; +import java.security.AccessController; +import java.security.PrivilegedAction; import java.util.ArrayList; import java.util.Collection; import java.util.Comparator; @@ -62,12 +64,17 @@ final class PropMap implements SortedMap { Properties props = new Properties(); // Allow implementation selected via -Dpack.disable.native=true + String propValue = getPropertyValue(Utils.DEBUG_DISABLE_NATIVE, "false"); props.put(Utils.DEBUG_DISABLE_NATIVE, - String.valueOf(Boolean.getBoolean(Utils.DEBUG_DISABLE_NATIVE))); + String.valueOf(Boolean.parseBoolean(propValue))); // Set the DEBUG_VERBOSE from system - props.put(Utils.DEBUG_VERBOSE, - String.valueOf(Integer.getInteger(Utils.DEBUG_VERBOSE,0))); + int verbose = 0; + try { + verbose = Integer.decode(getPropertyValue(Utils.DEBUG_VERBOSE, "0")); + } catch (NumberFormatException e) { + } + props.put(Utils.DEBUG_VERBOSE, String.valueOf(verbose)); // The segment size is unlimited props.put(Pack200.Packer.SEGMENT_LIMIT, "-1"); @@ -87,7 +94,7 @@ final class PropMap implements SortedMap { // Pass through files with unrecognized format by default, also // allow system property to be set props.put(Utils.CLASS_FORMAT_ERROR, - System.getProperty(Utils.CLASS_FORMAT_ERROR, Pack200.Packer.PASS)); + getPropertyValue(Utils.CLASS_FORMAT_ERROR, Pack200.Packer.PASS)); // Default effort is 5, midway between 1 and 9. props.put(Pack200.Packer.EFFORT, "5"); @@ -97,7 +104,9 @@ final class PropMap implements SortedMap { // to allow override if necessary. String propFile = "intrinsic.properties"; - try (InputStream propStr = PackerImpl.class.getResourceAsStream(propFile)) { + PrivilegedAction pa = + () -> PackerImpl.class.getResourceAsStream(propFile); + try (InputStream propStr = AccessController.doPrivileged(pa)) { if (propStr == null) { throw new RuntimeException(propFile + " cannot be loaded"); } @@ -119,6 +128,12 @@ final class PropMap implements SortedMap { defaultProps = temp; } + private static String getPropertyValue(String key, String defaultValue) { + PrivilegedAction pa = () -> System.getProperty(key); + String s = AccessController.doPrivileged(pa); + return s != null ? s : defaultValue; + } + PropMap() { theMap.putAll(defaultProps); } diff --git a/jdk/src/java.base/share/classes/java/io/DataInput.java b/jdk/src/java.base/share/classes/java/io/DataInput.java index acc7f996878..70f78a6a068 100644 --- a/jdk/src/java.base/share/classes/java/io/DataInput.java +++ b/jdk/src/java.base/share/classes/java/io/DataInput.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1995, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1995, 2017, 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 @@ -59,8 +59,9 @@ package java.io; * far left-hand column. * *
- * + *
+ * + * * * * * - * + * * @@ -86,14 +87,14 @@ package java.io; * * * - * + * * * - * + * * * * - * + * * * - * + * * * - * + * * + * *
Bit values and bytes
* All characters in the range {@code '\u005Cu0001'} to @@ -71,7 +72,7 @@ package java.io; * Bit Values
Byte 1Byte 10 * bits 6-0 *
Bit Values
Byte 1Byte 11 * 1 * 0 * bits 10-6 *
Byte 2Byte 21 * 0 * bits 5-0 @@ -108,7 +109,7 @@ package java.io; * Bit Values
Byte 1Byte 11 * 1 * 1 @@ -116,17 +117,18 @@ package java.io; * bits 15-12 *
Byte 2Byte 21 * 0 * bits 11-6 *
Byte 3Byte 31 * 0 * bits 5-0 *
*
*

diff --git a/jdk/src/java.base/share/classes/java/io/OutputStreamWriter.java b/jdk/src/java.base/share/classes/java/io/OutputStreamWriter.java index 3d44f443b82..71ea81e8c03 100644 --- a/jdk/src/java.base/share/classes/java/io/OutputStreamWriter.java +++ b/jdk/src/java.base/share/classes/java/io/OutputStreamWriter.java @@ -40,10 +40,8 @@ import sun.nio.cs.StreamEncoder; * *

Each invocation of a write() method causes the encoding converter to be * invoked on the given character(s). The resulting bytes are accumulated in a - * buffer before being written to the underlying output stream. The size of - * this buffer may be specified, but by default it is large enough for most - * purposes. Note that the characters passed to the write() methods are not - * buffered. + * buffer before being written to the underlying output stream. Note that the + * characters passed to the write() methods are not buffered. * *

For top efficiency, consider wrapping an OutputStreamWriter within a * BufferedWriter so as to avoid frequent converter invocations. For example: diff --git a/jdk/src/java.base/share/classes/java/io/RandomAccessFile.java b/jdk/src/java.base/share/classes/java/io/RandomAccessFile.java index 4fb409ec977..b2e08f8cb27 100644 --- a/jdk/src/java.base/share/classes/java/io/RandomAccessFile.java +++ b/jdk/src/java.base/share/classes/java/io/RandomAccessFile.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2017, 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 @@ -136,8 +136,12 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable { * in which the file is to be opened. The permitted values and their * meanings are: * - * + *
+ * + * * + * + * * * + * *
Access mode permitted values and meanings
ValueMeaning
{@code "r"} Open for reading only. Invoking any of the {@code write} * methods of the resulting object will cause an @@ -153,6 +157,7 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable { * Open for reading and writing, as with {@code "rw"}, and also * require that every update to the file's content be written * synchronously to the underlying storage device.
* * The {@code "rws"} and {@code "rwd"} modes work much like the {@link diff --git a/jdk/src/java.base/share/classes/java/io/SerializablePermission.java b/jdk/src/java.base/share/classes/java/io/SerializablePermission.java index 8aded4dcad2..93034a165a4 100644 --- a/jdk/src/java.base/share/classes/java/io/SerializablePermission.java +++ b/jdk/src/java.base/share/classes/java/io/SerializablePermission.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, 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 @@ -44,12 +44,16 @@ import java.util.StringTokenizer; * and for each provides a description of what the permission allows * and a discussion of the risks of granting code the permission. * - * + *
+ * + * * * * * * + * + * * * * @@ -79,7 +83,7 @@ import java.util.StringTokenizer; * * - * + * *
Permission target name, what the permission allows, and associated risks
Permission Target NameWhat the Permission AllowsRisks of Allowing this Permission
enableSubclassImplementationCode could remove a configured filter and remove protections * already established.
* * @see java.security.BasicPermission diff --git a/jdk/src/java.base/share/classes/java/lang/Character.java b/jdk/src/java.base/share/classes/java/lang/Character.java index 028190da55b..fd6682e6196 100644 --- a/jdk/src/java.base/share/classes/java/lang/Character.java +++ b/jdk/src/java.base/share/classes/java/lang/Character.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2002, 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2002, 2017, 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 @@ -9566,7 +9566,9 @@ class Character implements java.io.Serializable, Comparable { * Determines if the specified character is ISO-LATIN-1 white space. * This method returns {@code true} for the following five * characters only: - * + *
+ * + * * * * @@ -9577,6 +9579,7 @@ class Character implements java.io.Serializable, Comparable { * * * + * *
truechars
{@code '\t'} {@code U+0009}{@code HORIZONTAL TABULATION}
{@code '\n'} {@code U+000A}{@code CARRIAGE RETURN}
{@code ' '} {@code U+0020}{@code SPACE}
* * @param ch the character to be tested. diff --git a/jdk/src/java.base/share/classes/java/lang/Class.java b/jdk/src/java.base/share/classes/java/lang/Class.java index a7f1262c3b5..4251a6963b4 100644 --- a/jdk/src/java.base/share/classes/java/lang/Class.java +++ b/jdk/src/java.base/share/classes/java/lang/Class.java @@ -724,18 +724,23 @@ public final class Class implements java.io.Serializable, * one or more '{@code [}' characters representing the depth of the array * nesting. The encoding of element type names is as follows: * - *

- * + *
Element Type     Encoding - *
boolean     Z - *
byte     B - *
char     C + *
+ * + * + * + * + * *
Element types and encodings
Element Type Encoding + *
boolean Z + *
byte B + *
char C *
class or interface - *     Lclassname; - *
double     D - *
float     F - *
int     I - *
long     J - *
short     S + * Lclassname; + *
double D + *
float F + *
int I + *
long J + *
short S + *
* *

The class or interface name classname is the binary name of diff --git a/jdk/src/java.base/share/classes/java/lang/ClassLoader.java b/jdk/src/java.base/share/classes/java/lang/ClassLoader.java index 2f6af4de922..fb9660f6072 100644 --- a/jdk/src/java.base/share/classes/java/lang/ClassLoader.java +++ b/jdk/src/java.base/share/classes/java/lang/ClassLoader.java @@ -119,18 +119,24 @@ import sun.security.util.SecurityConstants; * The Java run-time has the following built-in class loaders: * *

    - *
  • Bootstrap class loader. + *

  • Bootstrap class loader. * It is the virtual machine's built-in class loader, typically represented * as {@code null}, and does not have a parent.

    • - *
  • {@linkplain #getPlatformClassLoader() Platform class loader}. + *

  • {@linkplain #getPlatformClassLoader() Platform class loader}. * All platform classes are visible to the platform class loader * that can be used as the parent of a {@code ClassLoader} instance. * Platform classes include Java SE platform APIs, their implementation * classes and JDK-specific run-time classes that are defined by the - * platform class loader or its ancestors.

    • - *
  • {@linkplain #getSystemClassLoader() System class loader}. - * It is also known as application class - * loader and is distinct from the platform class loader. + * platform class loader or its ancestors. + *

    To allow for upgrading/overriding of modules defined to the platform + * class loader, and where classes in the upgraded version link to + * classes in modules defined to the application class loader, the + * platform class loader may delegate to the application class loader. + * In other words, classes in named modules defined to the application + * class loader may be visible to the platform class loader.

    • + *

  • {@linkplain #getSystemClassLoader() System class loader}. + * It is also known as application class loader and is distinct + * from the platform class loader. * The system class loader is typically used to define classes on the * application class path, module path, and JDK-specific tools. * The platform class loader is a parent or an ancestor of the system class @@ -368,6 +374,10 @@ public abstract class ClassLoader { * Creates a new class loader of the specified name and using the * specified parent class loader for delegation. * + * @apiNote If the parent is specified as {@code null} (for the + * bootstrap class loader) then there is no guarantee that all platform + * classes are visible. + * * @param name class loader name; or {@code null} if not named * @param parent the parent class loader * @@ -390,9 +400,12 @@ public abstract class ClassLoader { * delegation. * *

    If there is a security manager, its {@link - * SecurityManager#checkCreateClassLoader() - * checkCreateClassLoader} method is invoked. This may result in - * a security exception.

    + * SecurityManager#checkCreateClassLoader() checkCreateClassLoader} method + * is invoked. This may result in a security exception.

    + * + * @apiNote If the parent is specified as {@code null} (for the + * bootstrap class loader) then there is no guarantee that all platform + * classes are visible. * * @param parent * The parent class loader @@ -2206,6 +2219,12 @@ public abstract class ClassLoader { * this class loader are searched recursively (parent by parent) * for a {@code Package} of the given name. * + * @apiNote The {@link #getPlatformClassLoader() platform class loader} + * may delegate to the application class loader but the application class + * loader is not its ancestor. When invoked on the platform class loader, + * this method will not find packages defined to the application + * class loader. + * * @param name * The package name * @@ -2251,6 +2270,14 @@ public abstract class ClassLoader { * {@code Package} object of the same package name, each defined by * a different class loader in the class loader hierarchy. * + * @apiNote The {@link #getPlatformClassLoader() platform class loader} + * may delegate to the application class loader. In other words, + * packages in modules defined to the application class loader may be + * visible to the platform class loader. On the other hand, + * the application class loader is not its ancestor and hence + * when invoked on the platform class loader, this method will not + * return any packages defined to the application class loader. + * * @return The array of {@code Package} objects defined by this * class loader and its ancestors * diff --git a/jdk/src/java.base/share/classes/java/lang/Double.java b/jdk/src/java.base/share/classes/java/lang/Double.java index 75a227e5282..a7aa0a0f626 100644 --- a/jdk/src/java.base/share/classes/java/lang/Double.java +++ b/jdk/src/java.base/share/classes/java/lang/Double.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2017, 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 @@ -255,9 +255,12 @@ public final class Double extends Number implements Comparable { * *
* - * + *
* + * * + * + * * * * @@ -272,6 +275,7 @@ public final class Double extends Number implements Comparable { * * * + * *
Examples
Floating-point ValueHexadecimal String
{@code 1.0} {@code 0x1.0p0}
{@code -1.0} {@code -0x1.0p0}
{@code 2.0} {@code 0x1.0p1}{@code 0x0.fffffffffffffp-1022}
{@code Double.MIN_VALUE}{@code 0x0.0000000000001p-1022}
* @param d the {@code double} to be converted. * @return a hex string representation of the argument. diff --git a/jdk/src/java.base/share/classes/java/lang/Float.java b/jdk/src/java.base/share/classes/java/lang/Float.java index 60e08db7ad5..77c1d1671d5 100644 --- a/jdk/src/java.base/share/classes/java/lang/Float.java +++ b/jdk/src/java.base/share/classes/java/lang/Float.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1994, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1994, 2017, 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 @@ -256,9 +256,12 @@ public final class Float extends Number implements Comparable { * * * - * + *
* + * * + * + * * * * @@ -273,6 +276,7 @@ public final class Float extends Number implements Comparable { * * * + * *
Examples
Floating-point ValueHexadecimal String
{@code 1.0} {@code 0x1.0p0}
{@code -1.0} {@code -0x1.0p0}
{@code 2.0} {@code 0x1.0p1}{@code 0x0.fffffep-126}
{@code Float.MIN_VALUE}{@code 0x0.000002p-126}
* @param f the {@code float} to be converted. * @return a hex string representation of the argument. diff --git a/jdk/src/java.base/share/classes/java/lang/Module.java b/jdk/src/java.base/share/classes/java/lang/Module.java index 26337d86beb..f6ab49b4519 100644 --- a/jdk/src/java.base/share/classes/java/lang/Module.java +++ b/jdk/src/java.base/share/classes/java/lang/Module.java @@ -57,6 +57,7 @@ import jdk.internal.loader.BuiltinClassLoader; import jdk.internal.loader.BootLoader; import jdk.internal.misc.JavaLangAccess; import jdk.internal.misc.SharedSecrets; +import jdk.internal.module.ModuleLoaderMap; import jdk.internal.module.ServicesCatalog; import jdk.internal.module.Resources; import jdk.internal.org.objectweb.asm.AnnotationVisitor; @@ -215,8 +216,8 @@ public final class Module implements AnnotatedElement { } /** - * Returns the layer that contains this module or {@code null} if this - * module is not in a layer. + * Returns the module layer that contains this module or {@code null} if + * this module is not in a module layer. * * A module layer contains named modules and therefore this method always * returns {@code null} when invoked on an unnamed module. @@ -691,6 +692,13 @@ public final class Module implements AnnotatedElement { *

This method has no effect if the package is already open * to the given module.

* + * @apiNote This method can be used for cases where a consumer + * module uses a qualified opens to open a package to an API + * module but where the reflective access to the members of classes in + * the consumer module is delegated to code in another module. Code in the + * API module can use this method to open the package in the consumer module + * to the other module. + * * @param pn * The package name * @param other @@ -1077,7 +1085,7 @@ public final class Module implements AnnotatedElement { if (loader != null) { moduleToLoader.put(name, loader); loaders.add(loader); - } else if (!isBootLayer) { + } else if (!(clf instanceof ModuleLoaderMap.Mapper)) { throw new IllegalArgumentException("loader can't be 'null'"); } } @@ -1458,11 +1466,11 @@ public final class Module implements AnnotatedElement { * encapsulated. * *
  • A package name is derived from the resource name. If - * the package name is a {@link #getPackages() package} in the module - * then the resource can only be located by the caller of this method - * when the package is {@link #isOpen(String,Module) open} to at least - * the caller's module. If the resource is not in a package in the module - * then the resource is not encapsulated.
    • + * the package name is a {@linkplain #getPackages() package} in the + * module then the resource can only be located by the caller of this + * method when the package is {@linkplain #isOpen(String,Module) open} + * to at least the caller's module. If the resource is not in a + * package in the module then the resource is not encapsulated. * * *

    In the above, the package name for a resource is derived @@ -1521,8 +1529,7 @@ public final class Module implements AnnotatedElement { } // locate resource in module - JavaLangAccess jla = SharedSecrets.getJavaLangAccess(); - URL url = jla.findResource(loader, mn, name); + URL url = loader.findResource(mn, name); if (url != null) { try { return url.openStream(); diff --git a/jdk/src/java.base/share/classes/java/lang/RuntimePermission.java b/jdk/src/java.base/share/classes/java/lang/RuntimePermission.java index 489bcf64375..b1a4280498a 100644 --- a/jdk/src/java.base/share/classes/java/lang/RuntimePermission.java +++ b/jdk/src/java.base/share/classes/java/lang/RuntimePermission.java @@ -43,13 +43,17 @@ import java.lang.module.ModuleFinder; * target names, and for each provides a description of what the permission * allows and a discussion of the risks of granting code the permission. * - * + *
    + * + * * * * * * + * + * * * * @@ -383,6 +387,7 @@ import java.lang.module.ModuleFinder; * {@linkplain ModuleFinder#ofSystem system modules} in the runtime image. * * + * *
    permission target name, + * what the target allows, and associated risks
    Permission Target NameWhat the Permission AllowsRisks of Allowing this Permission
    createClassLoader
    * * @implNote diff --git a/jdk/src/java.base/share/classes/java/lang/SecurityManager.java b/jdk/src/java.base/share/classes/java/lang/SecurityManager.java index 098e8626525..b60d63e5f02 100644 --- a/jdk/src/java.base/share/classes/java/lang/SecurityManager.java +++ b/jdk/src/java.base/share/classes/java/lang/SecurityManager.java @@ -25,10 +25,10 @@ package java.lang; -import java.lang.RuntimePermission; import java.lang.module.ModuleDescriptor; import java.lang.module.ModuleDescriptor.Exports; import java.lang.module.ModuleDescriptor.Opens; +import java.lang.module.ModuleReference; import java.lang.reflect.Member; import java.io.FileDescriptor; import java.io.File; @@ -42,12 +42,15 @@ import java.security.PrivilegedAction; import java.security.Security; import java.security.SecurityPermission; import java.util.HashSet; +import java.util.Map; import java.util.Objects; import java.util.PropertyPermission; import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; -import java.util.stream.Stream; +import jdk.internal.module.ModuleBootstrap; +import jdk.internal.module.ModuleLoaderMap; import jdk.internal.reflect.CallerSensitive; import sun.security.util.SecurityConstants; @@ -1431,30 +1434,30 @@ class SecurityManager { return packages; } - // The non-exported packages of the modules in the boot layer that are - // loaded by the platform class loader or its ancestors. A non-exported - // package is a package that either is not exported at all by its containing - // module or is exported in a qualified fashion by its containing module. - private static final Set nonExportedPkgs; - + // The non-exported packages in modules defined to the boot or platform + // class loaders. A non-exported package is a package that is not exported + // or is only exported to specific modules. + private static final Map nonExportedPkgs = new ConcurrentHashMap<>(); static { - // Get the modules in the boot layer - Stream bootLayerModules = ModuleLayer.boot().modules().stream(); - - // Filter out the modules loaded by the boot or platform loader - PrivilegedAction> pa = () -> - bootLayerModules.filter(SecurityManager::isBootOrPlatformModule) - .collect(Collectors.toSet()); - Set modules = AccessController.doPrivileged(pa); - - // Filter out the non-exported packages - nonExportedPkgs = modules.stream() - .map(Module::getDescriptor) - .map(SecurityManager::nonExportedPkgs) - .flatMap(Set::stream) - .collect(Collectors.toSet()); + addNonExportedPackages(ModuleLayer.boot()); } + /** + * Record the non-exported packages of the modules in the given layer + */ + static void addNonExportedPackages(ModuleLayer layer) { + Set bootModules = ModuleLoaderMap.bootModules(); + Set platformModules = ModuleLoaderMap.platformModules(); + layer.modules().stream() + .map(Module::getDescriptor) + .filter(md -> bootModules.contains(md.name()) + || platformModules.contains(md.name())) + .map(SecurityManager::nonExportedPkgs) + .flatMap(Set::stream) + .forEach(pn -> nonExportedPkgs.put(pn, Boolean.TRUE)); + } + + /** * Called by java.security.Security */ @@ -1467,14 +1470,6 @@ class SecurityManager { } } - /** - * Returns true if the module's loader is the boot or platform loader. - */ - private static boolean isBootOrPlatformModule(Module m) { - return m.getClassLoader() == null || - m.getClassLoader() == ClassLoader.getPlatformClassLoader(); - } - /** * Returns the non-exported packages of the specified module. */ @@ -1535,7 +1530,7 @@ class SecurityManager { Objects.requireNonNull(pkg, "package name can't be null"); // check if pkg is not exported to all modules - if (nonExportedPkgs.contains(pkg)) { + if (nonExportedPkgs.containsKey(pkg)) { checkPermission( new RuntimePermission("accessClassInPackage." + pkg)); return; @@ -1634,7 +1629,7 @@ class SecurityManager { Objects.requireNonNull(pkg, "package name can't be null"); // check if pkg is not exported to all modules - if (nonExportedPkgs.contains(pkg)) { + if (nonExportedPkgs.containsKey(pkg)) { checkPermission( new RuntimePermission("defineClassInPackage." + pkg)); return; diff --git a/jdk/src/java.base/share/classes/java/lang/String.java b/jdk/src/java.base/share/classes/java/lang/String.java index 1bd125dae54..ea94633597c 100644 --- a/jdk/src/java.base/share/classes/java/lang/String.java +++ b/jdk/src/java.base/share/classes/java/lang/String.java @@ -335,7 +335,7 @@ public final class String * subarray. * *

    Each {@code byte} in the subarray is converted to a {@code char} as - * specified in the method above. + * specified in the {@link #String(byte[],int) String(byte[],int)} constructor. * * @deprecated This method does not properly convert bytes into characters. * As of JDK 1.1, the preferred way to do this is via the @@ -390,7 +390,7 @@ public final class String /** * Allocates a new {@code String} containing characters constructed from - * an array of 8-bit integer values. Each character cin the + * an array of 8-bit integer values. Each character c in the * resulting string is constructed from the corresponding component * b in the byte array such that: * @@ -2203,12 +2203,16 @@ public final class String *

    The string {@code "boo:and:foo"}, for example, yields the * following results with these parameters: * - *

    + *
    + * + * * * * * * + * + * * * * @@ -2227,6 +2231,7 @@ public final class String * * * + * *
    Split example showing regex, limit, and result
    RegexLimitResult
    :2{@code { "boo", "and:foo" }}
    o0{@code { "b", "", ":and:f" }}
    * *

    An invocation of this method of the form @@ -2326,15 +2331,20 @@ public final class String *

    The string {@code "boo:and:foo"}, for example, yields the following * results with these expressions: * - *

    + *
    + * + * * * * * + * + * * * * * + * *
    Split examples showing regex and result
    RegexResult
    :{@code { "boo", "and", "foo" }}
    o{@code { "b", "", ":and:f" }}
    * * @@ -2445,13 +2455,17 @@ public final class String * {@code String} may be a different length than the original {@code String}. *

    * Examples of lowercase mappings are in the following table: - * + *
    + * + * * * * * * * + * + * * * * @@ -2480,6 +2494,7 @@ public final class String * sigma * * + * *
    Lowercase mapping examples showing language code of locale, upper case, lower case, and description
    Language Code of LocaleUpper CaseLower CaseDescription
    tr (Turkish)\u0130lowercased all chars in String
    * * @param locale use the case transformation rules for this locale @@ -2526,13 +2541,17 @@ public final class String *

    * Examples of locale-sensitive and 1:M case mappings are in the following table. * - * + *
    + * + * * * * * * * + * + * * * * @@ -2557,6 +2576,7 @@ public final class String * * * + * *
    Examples of locale-sensitive and 1:M case mappings. Shows Language code of locale, lower case, upper case, and description.
    Language Code of LocaleLower CaseUpper CaseDescription
    tr (Turkish)\u0069FAHRVERGNÜGEN
    * @param locale use the case transformation rules for this locale * @return the {@code String}, converted to uppercase. diff --git a/jdk/src/java.base/share/classes/java/lang/System.java b/jdk/src/java.base/share/classes/java/lang/System.java index edd5b553db1..10664819e4f 100644 --- a/jdk/src/java.base/share/classes/java/lang/System.java +++ b/jdk/src/java.base/share/classes/java/lang/System.java @@ -41,7 +41,6 @@ import java.lang.reflect.Executable; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.net.URI; -import java.net.URL; import java.security.AccessControlContext; import java.security.ProtectionDomain; import java.security.AccessController; @@ -576,9 +575,13 @@ public final class System { * system properties, a set of system properties is first created and * initialized. This set of system properties always includes values * for the following keys: - * + *
    + * + * * * + * + * * * @@ -637,6 +640,7 @@ public final class System { * * * + * *
    Shows property keys and associated values
    KeyDescription of Associated Value
    java.versionJava Runtime Environment version which may be interpreted * as a {@link Runtime.Version}
    User's home directory
    user.dirUser's current working directory
    *

    * Multiple paths in a system property value are separated by the path @@ -648,9 +652,13 @@ public final class System { * * @implNote In addition to the standard system properties, the system * properties may include the following keys: - * + *
    + * + * * * + * + * * * * @@ -659,6 +667,7 @@ public final class System { * * * + * *
    Shows property keys and associated values
    KeyDescription of Associated Value
    {@code jdk.module.path}The application module path
    {@code jdk.module.upgrade.path}The module name of the initial/main module
    {@code jdk.module.main.class}The main class name of the initial module
    * * @return the system properties @@ -2111,9 +2120,6 @@ public final class System { public Class findBootstrapClassOrNull(ClassLoader cl, String name) { return cl.findBootstrapClassOrNull(name); } - public URL findResource(ClassLoader cl, String mn, String name) throws IOException { - return cl.findResource(mn, name); - } public Stream packages(ClassLoader cl) { return cl.packages(); } @@ -2123,6 +2129,9 @@ public final class System { public String fastUUID(long lsb, long msb) { return Long.fastUUID(lsb, msb); } + public void addNonExportedPackages(ModuleLayer layer) { + SecurityManager.addNonExportedPackages(layer); + } public void invalidatePackageAccessCache() { SecurityManager.invalidatePackageAccessCache(); } diff --git a/jdk/src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java b/jdk/src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java index b09744cba7d..95719763b0f 100644 --- a/jdk/src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java +++ b/jdk/src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2017, 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 @@ -149,8 +149,12 @@ import java.util.Arrays; * capture argument (corresponding to the receiver) must be non-null. * *

    A type Q is considered adaptable to S as follows: - * + *
    + * + * * + * + * * * * @@ -176,6 +180,7 @@ import java.util.Arrays; *
    for return types: none * * + * *
    adaptable types
    QSLink-time checksInvocation-time checks
    PrimitivePrimitiveQ can be converted to S via a primitive widening conversionCast from Q to S
    * * @apiNote These linkage methods are designed to support the evaluation @@ -213,7 +218,9 @@ import java.util.Arrays; * methods. * @since 1.8 */ -public class LambdaMetafactory { +public final class LambdaMetafactory { + + private LambdaMetafactory() {} /** Flag for alternate metafactories indicating the lambda object * must be serializable */ diff --git a/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandleInfo.java b/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandleInfo.java index a53e0076756..909f271c672 100644 --- a/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandleInfo.java +++ b/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandleInfo.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2017, 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 @@ -81,8 +81,12 @@ import static java.lang.invoke.MethodHandleStatics.*; * The Lookup Factory Methods * correspond to all major use cases for methods, constructors, and fields. * These use cases may be distinguished using small integers as follows: - * + *
    + * + * * + * + * * * * @@ -119,6 +123,7 @@ import static java.lang.invoke.MethodHandleStatics.*; * * * + * *
    reference kinds
    reference kinddescriptive namescopememberbehavior
    {@code 1}{@code REF_getField}{@code class}{@code FT f;}{@code (T) this.f;}{@code 9}{@code REF_invokeInterface}{@code interface}{@code T m(A*);}{@code (T) this.m(arg*);}
    * @since 1.8 */ diff --git a/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandles.java b/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandles.java index cb5a398d68d..292fd9bb6c4 100644 --- a/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandles.java +++ b/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandles.java @@ -112,6 +112,19 @@ public class MethodHandles { return new Lookup(Reflection.getCallerClass()); } + /** + * This reflected$lookup method is the alternate implementation of + * the lookup method when being invoked by reflection. + */ + @CallerSensitive + private static Lookup reflected$lookup() { + Class caller = Reflection.getCallerClass(); + if (caller.getClassLoader() == null) { + throw newIllegalArgumentException("illegal lookupClass: "+caller); + } + return new Lookup(caller); + } + /** * Returns a {@link Lookup lookup object} which is trusted minimally. * The lookup has the {@code PUBLIC} and {@code UNCONDITIONAL} modes. @@ -265,12 +278,16 @@ public class MethodHandles { * (Bytecode behaviors are described in section 5.4.3.5 of the Java Virtual Machine Specification.) * Here is a summary of the correspondence between these factory methods and * the behavior of the resulting method handles: - * + *
    + * + * * * * * * + * + * * * * @@ -327,6 +344,7 @@ public class MethodHandles { * * * + * *
    lookup method behaviors
    lookup expressionmemberbytecode behavior
    {@link java.lang.invoke.MethodHandles.Lookup#findGetter lookup.findGetter(C.class,"f",FT.class)}{@code FT f;}{@code (T) this.f;}{@link java.lang.invoke.MethodHandles.Lookup#findClass lookup.findClass("C")}{@code class C { ... }}{@code C.class;}
    * * Here, the type {@code C} is the class or interface being searched for a member, @@ -747,7 +765,7 @@ public class MethodHandles { Lookup(Class lookupClass) { this(lookupClass, FULL_POWER_MODES); // make sure we haven't accidentally picked up a privileged class: - checkUnprivilegedlookupClass(lookupClass, FULL_POWER_MODES); + checkUnprivilegedlookupClass(lookupClass); } private Lookup(Class lookupClass, int allowedModes) { @@ -827,7 +845,7 @@ public class MethodHandles { newModes = 0; } - checkUnprivilegedlookupClass(requestedLookupClass, newModes); + checkUnprivilegedlookupClass(requestedLookupClass); return new Lookup(requestedLookupClass, newModes); } @@ -876,9 +894,7 @@ public class MethodHandles { * accessible to the class. The {@code PACKAGE} lookup mode serves to authenticate * that the lookup object was created by a caller in the runtime package (or derived * from a lookup originally created by suitably privileged code to a target class in - * the runtime package). The lookup modes cannot include {@link #PRIVATE PRIVATE} - * access. A lookup with {@code PRIVATE} access can be downgraded to drop this lookup - * mode with the {@linkplain #dropLookupMode(int) dropLookupMode} method.

    + * the runtime package).

    * *

    The {@code bytes} parameter is the class bytes of a valid class file (as defined * by the The Java Virtual Machine Specification) with a class name in the @@ -896,7 +912,6 @@ public class MethodHandles { * @throws IllegalArgumentException the bytes are for a class in a different package * to the lookup class * @throws IllegalAccessException if this lookup does not have {@code PACKAGE} access - * @throws UnsupportedOperationException if the lookup class has {@code PRIVATE} access * @throws LinkageError if the class is malformed ({@code ClassFormatError}), cannot be * verified ({@code VerifyError}), is already defined, or another linkage error occurs * @throws SecurityException if denied by the security manager @@ -911,8 +926,6 @@ public class MethodHandles { SecurityManager sm = System.getSecurityManager(); if (sm != null) sm.checkPermission(new RuntimePermission("defineClass")); - if (hasPrivateAccess()) - throw new UnsupportedOperationException("PRIVATE access not supported"); if ((lookupModes() & PACKAGE) == 0) throw new IllegalAccessException("Lookup does not have PACKAGE access"); assert (lookupModes() & (MODULE|PUBLIC)) != 0; @@ -984,25 +997,10 @@ public class MethodHandles { */ static final Lookup PUBLIC_LOOKUP = new Lookup(Object.class, (PUBLIC|UNCONDITIONAL)); - private static void checkUnprivilegedlookupClass(Class lookupClass, int allowedModes) { + private static void checkUnprivilegedlookupClass(Class lookupClass) { String name = lookupClass.getName(); if (name.startsWith("java.lang.invoke.")) throw newIllegalArgumentException("illegal lookupClass: "+lookupClass); - - // For caller-sensitive MethodHandles.lookup() disallow lookup from - // restricted packages. This a fragile and blunt approach. - // TODO replace with a more formal and less fragile mechanism - // that does not bluntly restrict classes under packages within - // java.base from looking up MethodHandles or VarHandles. - if (allowedModes == FULL_POWER_MODES && lookupClass.getClassLoader() == null) { - if ((name.startsWith("java.") && - !name.equals("java.lang.Thread") && - !name.startsWith("java.util.concurrent.")) || - (name.startsWith("sun.") && - !name.startsWith("sun.invoke."))) { - throw newIllegalArgumentException("illegal lookupClass: " + lookupClass); - } - } } /** @@ -1447,9 +1445,10 @@ assertEquals(""+l, (String) MH_this.invokeExact(subl)); // Listie method } /** - * Produces a VarHandle giving access to non-static fields of type - * {@code T} declared by a receiver class of type {@code R}, supporting - * shape {@code (R : T)}. + * Produces a VarHandle giving access to a non-static field {@code name} + * of type {@code type} declared in a class of type {@code recv}. + * The VarHandle's variable type is {@code type} and it has one + * coordinate type, {@code recv}. *

    * Access checking is performed immediately on behalf of the lookup * class. @@ -1472,7 +1471,7 @@ assertEquals(""+l, (String) MH_this.invokeExact(subl)); // Listie method *

    * If the field is declared {@code volatile} then the returned VarHandle * will override access to the field (effectively ignore the - * {@code volatile} declaration) in accordance to it's specified + * {@code volatile} declaration) in accordance to its specified * access modes. *

    * If the field type is {@code float} or {@code double} then numeric @@ -1568,9 +1567,10 @@ assertEquals(""+l, (String) MH_this.invokeExact(subl)); // Listie method } /** - * Produces a VarHandle giving access to a static field of type - * {@code T} declared by a given declaring class, supporting shape - * {@code ((empty) : T)}. + * Produces a VarHandle giving access to a static field {@code name} of + * type {@code type} declared in a class of type {@code decl}. + * The VarHandle's variable type is {@code type} and it has no + * coordinate types. *

    * Access checking is performed immediately on behalf of the lookup * class. @@ -1596,7 +1596,7 @@ assertEquals(""+l, (String) MH_this.invokeExact(subl)); // Listie method *

    * If the field is declared {@code volatile} then the returned VarHandle * will override access to the field (effectively ignore the - * {@code volatile} declaration) in accordance to it's specified + * {@code volatile} declaration) in accordance to its specified * access modes. *

    * If the field type is {@code float} or {@code double} then numeric @@ -1691,7 +1691,13 @@ return mh1; public MethodHandle bind(Object receiver, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException { Class refc = receiver.getClass(); // may get NPE MemberName method = resolveOrFail(REF_invokeSpecial, refc, name, type); - MethodHandle mh = getDirectMethodNoRestrict(REF_invokeSpecial, refc, method, findBoundCallerClass(method)); + MethodHandle mh = getDirectMethodNoRestrictInvokeSpecial(refc, method, findBoundCallerClass(method)); + if (!mh.type().leadingReferenceParameter().isAssignableFrom(receiver.getClass())) { + throw new IllegalAccessException("The restricted defining class " + + mh.type().leadingReferenceParameter().getName() + + " is not assignable from receiver class " + + receiver.getClass().getName()); + } return mh.bindArgumentL(0, receiver).setVarargs(method); } @@ -1877,11 +1883,12 @@ return mh1; } /** - * Produces a VarHandle that accesses fields of type {@code T} declared - * by a class of type {@code R}, as described by the given reflected - * field. - * If the field is non-static the VarHandle supports a shape of - * {@code (R : T)}, otherwise supports a shape of {@code ((empty) : T)}. + * Produces a VarHandle giving access to a reflected field {@code f} + * of type {@code T} declared in a class of type {@code R}. + * The VarHandle's variable type is {@code T}. + * If the field is non-static the VarHandle has one coordinate type, + * {@code R}. Otherwise, the field is static, and the VarHandle has no + * coordinate types. *

    * Access checking is performed immediately on behalf of the lookup * class, regardless of the value of the field's {@code accessible} @@ -1909,7 +1916,7 @@ return mh1; *

    * If the field is declared {@code volatile} then the returned VarHandle * will override access to the field (effectively ignore the - * {@code volatile} declaration) in accordance to it's specified + * {@code volatile} declaration) in accordance to its specified * access modes. *

    * If the field type is {@code float} or {@code double} then numeric @@ -2240,7 +2247,7 @@ return mh1; throw method.makeAccessException("caller class must be a subclass below the method", caller); } MethodType rawType = mh.type(); - if (rawType.parameterType(0) == caller) return mh; + if (caller.isAssignableFrom(rawType.parameterType(0))) return mh; // no need to restrict; already narrow MethodType narrowType = rawType.changeParameterType(0, caller); assert(!mh.isVarargsCollector()); // viewAsType will lose varargs-ness assert(mh.viewAsTypeChecks(narrowType, true)); @@ -2253,11 +2260,11 @@ return mh1; final boolean checkSecurity = true; return getDirectMethodCommon(refKind, refc, method, checkSecurity, doRestrict, callerClass); } - /** Check access and get the requested method, eliding receiver narrowing rules. */ - private MethodHandle getDirectMethodNoRestrict(byte refKind, Class refc, MemberName method, Class callerClass) throws IllegalAccessException { + /** Check access and get the requested method, for invokespecial with no restriction on the application of narrowing rules. */ + private MethodHandle getDirectMethodNoRestrictInvokeSpecial(Class refc, MemberName method, Class callerClass) throws IllegalAccessException { final boolean doRestrict = false; final boolean checkSecurity = true; - return getDirectMethodCommon(refKind, refc, method, checkSecurity, doRestrict, callerClass); + return getDirectMethodCommon(REF_invokeSpecial, refc, method, checkSecurity, doRestrict, callerClass); } /** Check access and get the requested method, eliding security manager checks. */ private MethodHandle getDirectMethodNoSecurityManager(byte refKind, Class refc, MemberName method, Class callerClass) throws IllegalAccessException { @@ -2309,10 +2316,8 @@ return mh1; DirectMethodHandle dmh = DirectMethodHandle.make(refKind, refc, method); MethodHandle mh = dmh; // Optionally narrow the receiver argument to refc using restrictReceiver. - if (doRestrict && - (refKind == REF_invokeSpecial || - (MethodHandleNatives.refKindHasReceiver(refKind) && - restrictProtectedReceiver(method)))) { + if ((doRestrict && refKind == REF_invokeSpecial) || + (MethodHandleNatives.refKindHasReceiver(refKind) && restrictProtectedReceiver(method))) { mh = restrictReceiver(method, dmh, lookupClass()); } mh = maybeBindCaller(method, mh, callerClass); @@ -2572,9 +2577,11 @@ return mh1; } /** - * - * Produces a VarHandle giving access to elements of an array type - * {@code T[]}, supporting shape {@code (T[], int : T)}. + * Produces a VarHandle giving access to elements of an array of type + * {@code arrayClass}. The VarHandle's variable type is the component type + * of {@code arrayClass} and the list of coordinate types is + * {@code (arrayClass, int)}, where the {@code int} coordinate type + * corresponds to an argument that is an index into an array. *

    * Certain access modes of the returned VarHandle are unsupported under * the following conditions: @@ -2629,13 +2636,14 @@ return mh1; /** * Produces a VarHandle giving access to elements of a {@code byte[]} array * viewed as if it were a different primitive array type, such as - * {@code int[]} or {@code long[]}. The shape of the resulting VarHandle is - * {@code (byte[], int : T)}, where the {@code int} coordinate type - * corresponds to an argument that is an index in a {@code byte[]} array, - * and {@code T} is the component type of the given view array class. The - * returned VarHandle accesses bytes at an index in a {@code byte[]} array, - * composing bytes to or from a value of {@code T} according to the given - * endianness. + * {@code int[]} or {@code long[]}. + * The VarHandle's variable type is the component type of + * {@code viewArrayClass} and the list of coordinate types is + * {@code (byte[], int)}, where the {@code int} coordinate type + * corresponds to an argument that is an index into a {@code byte[]} array. + * The returned VarHandle accesses bytes at an index in a {@code byte[]} + * array, composing bytes to or from a value of the component type of + * {@code viewArrayClass} according to the given endianness. *

    * The supported component types (variables types) are {@code short}, * {@code char}, {@code int}, {@code long}, {@code float} and @@ -2713,13 +2721,14 @@ return mh1; * Produces a VarHandle giving access to elements of a {@code ByteBuffer} * viewed as if it were an array of elements of a different primitive * component type to that of {@code byte}, such as {@code int[]} or - * {@code long[]}. The shape of the resulting VarHandle is - * {@code (ByteBuffer, int : T)}, where the {@code int} coordinate type - * corresponds to an argument that is an index in a {@code ByteBuffer}, and - * {@code T} is the component type of the given view array class. The - * returned VarHandle accesses bytes at an index in a {@code ByteBuffer}, - * composing bytes to or from a value of {@code T} according to the given - * endianness. + * {@code long[]}. + * The VarHandle's variable type is the component type of + * {@code viewArrayClass} and the list of coordinate types is + * {@code (ByteBuffer, int)}, where the {@code int} coordinate type + * corresponds to an argument that is an index into a {@code byte[]} array. + * The returned VarHandle accesses bytes at an index in a + * {@code ByteBuffer}, composing bytes to or from a value of the component + * type of {@code viewArrayClass} according to the given endianness. *

    * The supported component types (variables types) are {@code short}, * {@code char}, {@code int}, {@code long}, {@code float} and diff --git a/jdk/src/java.base/share/classes/java/lang/invoke/VarHandle.java b/jdk/src/java.base/share/classes/java/lang/invoke/VarHandle.java index ee0f712635c..9e2533f071e 100644 --- a/jdk/src/java.base/share/classes/java/lang/invoke/VarHandle.java +++ b/jdk/src/java.base/share/classes/java/lang/invoke/VarHandle.java @@ -41,7 +41,7 @@ import static java.lang.invoke.MethodHandleStatics.UNSAFE; import static java.lang.invoke.MethodHandleStatics.newInternalError; /** - * A VarHandle is a dynamically typed reference to a variable, or to a + * A VarHandle is a dynamically strongly typed reference to a variable, or to a * parametrically-defined family of variables, including static fields, * non-static fields, array elements, or components of an off-heap data * structure. Access to such variables is supported under various @@ -53,63 +53,62 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError; * *

    A VarHandle has: *

      - *
    • a {@link #varType variable type}, referred to as {@code T}, which is the - * type of variable(s) referenced by this VarHandle; - *
    • a list of {@link #coordinateTypes coordinate types}, referred to as - * {@code CT}, where the types (primitive and reference) are represented by - * {@link Class} objects). A list of arguments corresponding to instances of - * the coordinate types uniquely locates a variable referenced by this - * VarHandle; and - *
    • a shape, that combines the variable type and coordinate types, - * and is declared with the notation {@code (CT : T)}. An empty list of - * coordinate types is declared as {@code (empty)}. + *
    • a {@link #varType variable type} T, the type of every variable referenced + * by this VarHandle; and + *
    • a list of {@link #coordinateTypes coordinate types} + * {@code CT1, CT2, ..., CTn}, the types of coordinate expressions that + * jointly locate a variable referenced by this VarHandle. *
    + * Variable and coordinate types may be primitive or reference, and are + * represented by {@code Class} objects. The list of coordinate types may be + * empty. * *

    Factory methods that produce or {@link java.lang.invoke.MethodHandles.Lookup - * lookup} VarHandle instances document the supported variable type, coordinate - * types, and shape. + * lookup} VarHandle instances document the supported variable type and the list + * of coordinate types. * - * For example, a VarHandle referencing a non-static field will declare a shape - * of {@code (R : T)}, where {@code R} is the receiver type and - * {@code T} is the field type, and where the VarHandle and an instance of the - * receiver type can be utilized to access the field variable. - * A VarHandle referencing array elements will declare a shape of - * {@code (T[], int : T)}, where {@code T[]} is the array type and {@code T} - * its component type, and where the VarHandle, an instance of the array type, - * and an {@code int} index can be utilized to access an array element variable. + *

    Each access mode is associated with one access mode method, a + * signature polymorphic method named + * for the access mode. When an access mode method is invoked on a VarHandle + * instance, the initial arguments to the invocation are coordinate expressions + * that indicate in precisely which object the variable is to be accessed. + * Trailing arguments to the invocation represent values of importance to the + * access mode. For example, the various compare-and-set or compare-and-exchange + * access modes require two trailing arguments for the variable's expected value + * and new value. * - *

    Each access mode is associated with a - * signature polymorphic method of the - * same name, where the VarHandle shape and access mode uniquely determine the - * canonical {@link #accessModeType(AccessMode) access mode type}, - * which in turn determines the matching constraints on a valid symbolic - * type descriptor at the call site of an access mode's method - * invocation. + *

    The arity and types of arguments to the invocation of an access mode + * method are not checked statically. Instead, each access mode method + * specifies an {@link #accessModeType(AccessMode) access mode type}, + * represented as an instance of {@link MethodType}, that serves as a kind of + * method signature against which the arguments are checked dynamically. An + * access mode type gives formal parameter types in terms of the coordinate + * types of a VarHandle instance and the types for values of importance to the + * access mode. An access mode type also gives a return type, often in terms of + * the variable type of a VarHandle instance. When an access mode method is + * invoked on a VarHandle instance, the symbolic type descriptor at the + * call site, the run time types of arguments to the invocation, and the run + * time type of the return value, must match the types + * given in the access mode type. A runtime exception will be thrown if the + * match fails. * - * As such, VarHandles are dynamically and strongly typed. Their arity, - * argument types, and return type of an access mode method invocation are not - * statically checked. If they, and associated values, do not match the arity - * and types of the access mode's type, an exception will be thrown. - * - * The parameter types of an access mode method type will consist of those that - * are the VarHandles's coordinate types (in order), followed by access mode - * parameter types specific to the access mode. - * - *

    An access mode's method documents the form of its method signature, which - * is derived from the access mode parameter types. The form is declared with - * the notation {@code (CT, P1 p1, P2 p2, ..., PN pn)R}, where {@code CT} is the - * coordinate types (as documented by a VarHandle factory method), {@code P1}, - * {@code P2} and {@code PN} are the first, second and the n'th access mode - * parameters named {@code p1}, {@code p2} and {@code pn} respectively, and - * {@code R} is the return type. - * - * For example, for the generic shape of {@code (CT : T)} the - * {@link #compareAndSet} access mode method documents that its method - * signature is of the form {@code (CT, T expectedValue, T newValue)boolean}, - * where the parameter types named {@code extendedValue} and {@code newValue} - * are the access mode parameter types. If the VarHandle accesses array - * elements with a shape of say {@code (T[], int : T)} then the access mode - * method type is {@code (T[], int, T, T)boolean}. + * For example, the access mode method {@link #compareAndSet} specifies that if + * its receiver is a VarHandle instance with coordinate types + * {@code CT1, ..., CTn} and variable type {@code T}, then its access mode type + * is {@code (CT1 c1, ..., CTn cn, T expectedValue, T newValue)boolean}. + * Suppose that a VarHandle instance can access array elements, and that its + * coordinate types are {@code String[]} and {@code int} while its variable type + * is {@code String}. The access mode type for {@code compareAndSet} on this + * VarHandle instance would be + * {@code (String[] c1, int c2, String expectedValue, String newValue)boolean}. + * Such a VarHandle instance may produced by the + * {@link MethodHandles#arrayElementVarHandle(Class) array factory method} and + * access array elements as follows: + * 

     {@code
+ * String[] sa = ...
+ * VarHandle avh = MethodHandles.arrayElementVarHandle(String[].class);
+ * boolean r = avh.compareAndSet(sa, 10, "expected", "new");
+ * }
    * *

    Access modes are grouped into the following categories: *

      @@ -172,10 +171,10 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError; * lookup} VarHandle instances document the set of access modes that are * supported, which may also include documenting restrictions based on the * variable type and whether a variable is read-only. If an access mode is not - * supported then the corresponding signature-polymorphic method will on - * invocation throw an {@code UnsupportedOperationException}. Factory methods - * should document any additional undeclared exceptions that may be thrown by - * access mode methods. + * supported then the corresponding access mode method will on invocation throw + * an {@code UnsupportedOperationException}. Factory methods should document + * any additional undeclared exceptions that may be thrown by access mode + * methods. * The {@link #get get} access mode is supported for all * VarHandle instances and the corresponding method never throws * {@code UnsupportedOperationException}. @@ -215,7 +214,7 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError; * precise phrasing of the specification of access mode methods and memory fence * methods may accompany future updates of the Java Language Specification. * - *

      Compilation of an access mode's method

      + *

      Compiling invocation of access mode methods

      * A Java method call expression naming an access mode method can invoke a * VarHandle from Java source code. From the viewpoint of source code, these * methods can take any arguments and their polymorphic result (if expressed) @@ -247,7 +246,7 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError; * except the null reference. * * - *

      Invocation of an access mode's method

      + *

      Performing invocation of access mode methods

      * The first time an {@code invokevirtual} instruction is executed it is linked * by symbolically resolving the names in the instruction and verifying that * the method call is statically legal. This also holds for calls to access mode @@ -264,38 +263,31 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError; * invoking is not present on the individual VarHandle being invoked. * *

      - * Invocation of an access mode's signature-polymorphic method behaves as if an - * invocation of {@link MethodHandle#invoke}, where the receiving method handle - * is bound to a VarHandle instance and the access mode. More specifically, the - * following: + * Invocation of an access mode method behaves as if an invocation of + * {@link MethodHandle#invoke}, where the receiving method handle accepts the + * VarHandle instance as the leading argument. More specifically, the + * following, where {@code {access-mode}} corresponds to the access mode method + * name: * 

       {@code
  * VarHandle vh = ..
  * R r = (R) vh.{access-mode}(p1, p2, ..., pN);
  * }
      - * behaves as if (modulo the access mode methods do not declare throwing of - * {@code Throwable}): + * behaves as if: * 
       {@code
  * VarHandle vh = ..
+ * VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
  * MethodHandle mh = MethodHandles.varHandleExactInvoker(
- *                       VarHandle.AccessMode.{access-mode},
- *                       vh.accessModeType(VarHandle.AccessMode.{access-mode}));
+ *                       am,
+ *                       vh.accessModeType(am));
  *
- * mh = mh.bindTo(vh);
- * R r = (R) mh.invoke(p1, p2, ..., pN)
+ * R r = (R) mh.invoke(vh, p1, p2, ..., pN)
  * }
      - * or, more concisely, behaves as if: - * 
       {@code
- * VarHandle vh = ..
- * MethodHandle mh = vh.toMethodHandle(VarHandle.AccessMode.{access-mode});
- *
- * R r = (R) mh.invoke(p1, p2, ..., pN)
- * }
      - * In terms of equivalent {@code invokevirtual} bytecode behaviour an access - * mode method invocation is equivalent to: + * (modulo access mode methods do not declare throwing of {@code Throwable}). + * This is equivalent to: * 
       {@code
  * MethodHandle mh = MethodHandles.lookup().findVirtual(
  *                       VarHandle.class,
- *                       VarHandle.AccessMode.{access-mode}.methodName(),
+ *                       "{access-mode}",
  *                       MethodType.methodType(R, p1, p2, ..., pN));
  *
  * R r = (R) mh.invokeExact(vh, p1, p2, ..., pN)
@@ -306,6 +298,17 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError;
  * widen primitive values, as if by {@link MethodHandle#asType asType} (see also
  * {@link MethodHandles#varHandleInvoker}).
  *
+ * More concisely, such behaviour is equivalent to:
+ * 
       {@code
+ * VarHandle vh = ..
+ * VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
+ * MethodHandle mh = vh.toMethodHandle(am);
+ *
+ * R r = (R) mh.invoke(p1, p2, ..., pN)
+ * }
      
+ * Where, in this case, the method handle is bound to the VarHandle instance.
+ *
+ *
  * 
      Invocation checking
      
  * In typical programs, VarHandle access mode type matching will usually
  * succeed.  But if a match fails, the JVM will throw a
@@ -439,7 +442,7 @@ public abstract class VarHandle {
      * if the variable was declared non-{@code volatile}.  Commonly referred to
      * as plain read access.
      *
-     * 
      The method signature is of the form {@code (CT)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code get}
      * must match the access mode type that is the result of calling
@@ -449,15 +452,15 @@ public abstract class VarHandle {
      * throws {@code UnsupportedOperationException}.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -469,21 +472,21 @@ public abstract class VarHandle {
      * semantics of setting as if the variable was declared non-{@code volatile}
      * and non-{@code final}.  Commonly referred to as plain write access.
      *
-     * 
      The method signature is of the form {@code (CT, T newValue)void}
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}
      *
      * 
      The symbolic type descriptor at the call site of {@code set}
      * must match the access mode type that is the result of calling
      * {@code accessModeType(VarHandle.AccessMode.SET)} on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -497,7 +500,7 @@ public abstract class VarHandle {
      * Returns the value of a variable, with memory semantics of reading as if
      * the variable was declared {@code volatile}.
      *
-     * 
      The method signature is of the form {@code (CT)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getVolatile}
      * must match the access mode type that is the result of calling
@@ -505,17 +508,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn ctn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -526,7 +529,7 @@ public abstract class VarHandle {
      * Sets the value of a variable to the {@code newValue}, with memory
      * semantics of setting as if the variable was declared {@code volatile}.
      *
-     * 
      The method signature is of the form {@code (CT, T newValue)void}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
      *
      * 
      The symbolic type descriptor at the call site of {@code setVolatile}
      * must match the access mode type that is the result of calling
@@ -538,14 +541,14 @@ public abstract class VarHandle {
      * memory ordering effects compatible with {@code memory_order_seq_cst}.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -557,7 +560,7 @@ public abstract class VarHandle {
      * Returns the value of a variable, accessed in program order, but with no
      * assurance of memory ordering effects with respect to other threads.
      *
-     * 
      The method signature is of the form {@code (CT)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getOpaque}
      * must match the access mode type that is the result of calling
@@ -565,17 +568,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn ctn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -587,7 +590,7 @@ public abstract class VarHandle {
      * but with no assurance of memory ordering effects with respect to other
      * threads.
      *
-     * 
      The method signature is of the form {@code (CT, T newValue)void}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
      *
      * 
      The symbolic type descriptor at the call site of {@code setOpaque}
      * must match the access mode type that is the result of calling
@@ -595,14 +598,14 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -616,7 +619,7 @@ public abstract class VarHandle {
      * Returns the value of a variable, and ensures that subsequent loads and
      * stores are not reordered before this access.
      *
-     * 
      The method signature is of the form {@code (CT)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAcquire}
      * must match the access mode type that is the result of calling
@@ -629,17 +632,17 @@ public abstract class VarHandle {
      * ordering.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn ctn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -650,7 +653,7 @@ public abstract class VarHandle {
      * Sets the value of a variable to the {@code newValue}, and ensures that
      * prior loads and stores are not reordered after this access.
      *
-     * 
      The method signature is of the form {@code (CT, T newValue)void}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
      *
      * 
      The symbolic type descriptor at the call site of {@code setRelease}
      * must match the access mode type that is the result of calling
@@ -663,14 +666,14 @@ public abstract class VarHandle {
      * ordering.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -687,7 +690,7 @@ public abstract class VarHandle {
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * compareAndSet} must match the access mode type that is the result of
@@ -695,16 +698,16 @@ public abstract class VarHandle {
      * this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -720,7 +723,7 @@ public abstract class VarHandle {
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * compareAndExchange}
@@ -729,7 +732,7 @@ public abstract class VarHandle {
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the witness value, which
      * will be the same as the {@code expectedValue} if successful
@@ -755,7 +758,7 @@ public abstract class VarHandle {
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #getAcquire}.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * compareAndExchangeAcquire}
@@ -764,17 +767,17 @@ public abstract class VarHandle {
      * this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the witness value, which
      * will be the same as the {@code expectedValue} if successful
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -790,7 +793,7 @@ public abstract class VarHandle {
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #get}.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * compareAndExchangeRelease}
@@ -799,17 +802,17 @@ public abstract class VarHandle {
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the witness value, which
      * will be the same as the {@code expectedValue} if successful
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -830,7 +833,7 @@ public abstract class VarHandle {
      * 
      This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * weakCompareAndSetPlain} must match the access mode type that is the result of
@@ -838,17 +841,17 @@ public abstract class VarHandle {
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #get(Object...)
      */
@@ -867,7 +870,7 @@ public abstract class VarHandle {
      * 
      This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * weakCompareAndSet} must match the access mode type that is the
@@ -875,17 +878,17 @@ public abstract class VarHandle {
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -904,7 +907,7 @@ public abstract class VarHandle {
      * 
      This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * weakCompareAndSetAcquire}
@@ -913,17 +916,17 @@ public abstract class VarHandle {
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -942,7 +945,7 @@ public abstract class VarHandle {
      * 
      This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * 
      The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * 
      The symbolic type descriptor at the call site of {@code
      * weakCompareAndSetRelease}
@@ -951,17 +954,17 @@ public abstract class VarHandle {
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -976,7 +979,7 @@ public abstract class VarHandle {
      * previous value, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * 
      The method signature is of the form {@code (CT, T newValue)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndSet}
      * must match the access mode type that is the result of calling
@@ -984,17 +987,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1009,7 +1012,7 @@ public abstract class VarHandle {
      * previous value, as accessed with the memory semantics of
      * {@link #getAcquire}.
      *
-     * 
      The method signature is of the form {@code (CT, T newValue)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndSetAcquire}
      * must match the access mode type that is the result of calling
@@ -1017,17 +1020,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1042,7 +1045,7 @@ public abstract class VarHandle {
      * previous value, as accessed with the memory semantics of
      * {@link #get}.
      *
-     * 
      The method signature is of the form {@code (CT, T newValue)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndSetRelease}
      * must match the access mode type that is the result of calling
@@ -1050,17 +1053,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1078,7 +1081,7 @@ public abstract class VarHandle {
      * previous value, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * 
      The method signature is of the form {@code (CT, T value)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndAdd}
      * must match the access mode type that is the result of calling
@@ -1086,17 +1089,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T value)}
+     * {@code (CT1 ct1, ..., CTn ctn, T value)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1111,7 +1114,7 @@ public abstract class VarHandle {
      * previous value, as accessed with the memory semantics of
      * {@link #getAcquire}.
      *
-     * 
      The method signature is of the form {@code (CT, T value)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndAddAcquire}
      * must match the access mode type that is the result of calling
@@ -1119,17 +1122,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T value)}
+     * {@code (CT1 ct1, ..., CTn ctn, T value)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1144,7 +1147,7 @@ public abstract class VarHandle {
      * previous value, as accessed with the memory semantics of
      * {@link #get}.
      *
-     * 
      The method signature is of the form {@code (CT, T value)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndAddRelease}
      * must match the access mode type that is the result of calling
@@ -1152,17 +1155,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T value)}
+     * {@code (CT1 ct1, ..., CTn ctn, T value)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1185,7 +1188,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical OR is performed instead of a bitwise OR.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseOr}
      * must match the access mode type that is the result of calling
@@ -1193,17 +1196,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1222,7 +1225,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical OR is performed instead of a bitwise OR.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseOrAcquire}
      * must match the access mode type that is the result of calling
@@ -1230,17 +1233,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -1259,7 +1262,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical OR is performed instead of a bitwise OR.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseOrRelease}
      * must match the access mode type that is the result of calling
@@ -1267,17 +1270,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -1296,7 +1299,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical AND is performed instead of a bitwise AND.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseAnd}
      * must match the access mode type that is the result of calling
@@ -1304,17 +1307,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1333,7 +1336,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical AND is performed instead of a bitwise AND.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseAndAcquire}
      * must match the access mode type that is the result of calling
@@ -1341,17 +1344,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -1370,7 +1373,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical AND is performed instead of a bitwise AND.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseAndRelease}
      * must match the access mode type that is the result of calling
@@ -1378,17 +1381,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -1407,7 +1410,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical XOR is performed instead of a bitwise XOR.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseXor}
      * must match the access mode type that is the result of calling
@@ -1415,17 +1418,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1444,7 +1447,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical XOR is performed instead of a bitwise XOR.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseXorAcquire}
      * must match the access mode type that is the result of calling
@@ -1452,17 +1455,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -1481,7 +1484,7 @@ public abstract class VarHandle {
      * 
      If the variable type is the non-integral {@code boolean} type then a
      * logical XOR is performed instead of a bitwise XOR.
      *
-     * 
      The method signature is of the form {@code (CT, T mask)T}.
+     * 
      The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * 
      The symbolic type descriptor at the call site of {@code getAndBitwiseXorRelease}
      * must match the access mode type that is the result of calling
@@ -1489,17 +1492,17 @@ public abstract class VarHandle {
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -1790,7 +1793,7 @@ public abstract class VarHandle {
 
         /**
          * Returns the {@code VarHandle} signature-polymorphic method name
-         * associated with this {@code AccessMode} value
+         * associated with this {@code AccessMode} value.
          *
          * @return the signature-polymorphic method name
          * @see #valueFromMethodName
@@ -1861,14 +1864,13 @@ public abstract class VarHandle {
     }
 
     /**
-     * Obtains the canonical access mode type for this VarHandle and a given
-     * access mode.
+     * Obtains the access mode type for this VarHandle and a given access mode.
      *
      * 
      The access mode type's parameter types will consist of a prefix that
      * is the coordinate types of this VarHandle followed by further
-     * types as defined by the access mode's method.
+     * types as defined by the access mode method.
      * The access mode type's return type is defined by the return type of the
-     * access mode's method.
+     * access mode method.
      *
      * @param accessMode the access mode, corresponding to the
      * signature-polymorphic method of the same name
@@ -1891,7 +1893,7 @@ public abstract class VarHandle {
      *
      * 
      The return of a {@code false} value for a given access mode indicates
      * that an {@code UnsupportedOperationException} is thrown on invocation
-     * of the corresponding access mode's signature-polymorphic method.
+     * of the corresponding access mode method.
      *
      * @param accessMode the access mode, corresponding to the
      * signature-polymorphic method of the same name
@@ -1908,7 +1910,7 @@ public abstract class VarHandle {
      *
      * @apiNote This method, for a VarHandle {@code vh} and access mode
      * {@code {access-mode}}, returns a method handle that is equivalent to
-     * method handle {@code bhm} in the following code (though it may be more
+     * method handle {@code bmh} in the following code (though it may be more
      * efficient):
      * 
      {@code
      * MethodHandle mh = MethodHandles.varHandleExactInvoker(
diff --git a/jdk/src/java.base/share/classes/java/lang/module/Configuration.java b/jdk/src/java.base/share/classes/java/lang/module/Configuration.java
index d5fc16c1ef6..ef7e44a114d 100644
--- a/jdk/src/java.base/share/classes/java/lang/module/Configuration.java
+++ b/jdk/src/java.base/share/classes/java/lang/module/Configuration.java
@@ -109,20 +109,17 @@ public final class Configuration {
     private final Set modules;
     private final Map nameToModule;
 
-    // module constraints on target
-    private final String osName;
-    private final String osArch;
+    // constraint on target platform
+    private final String targetPlatform;
 
-    String osName() { return osName; }
-    String osArch() { return osArch; }
+    String targetPlatform() { return targetPlatform; }
 
     private Configuration() {
         this.parents = Collections.emptyList();
         this.graph = Collections.emptyMap();
         this.modules = Collections.emptySet();
         this.nameToModule = Collections.emptyMap();
-        this.osName = null;
-        this.osArch = null;
+        this.targetPlatform = null;
     }
 
     private Configuration(List parents,
@@ -147,8 +144,7 @@ public final class Configuration {
         this.modules = Set.of(moduleArray);
         this.nameToModule = Map.ofEntries(nameEntries);
 
-        this.osName = resolver.osName();
-        this.osArch = resolver.osArch();
+        this.targetPlatform = resolver.targetPlatform();
     }
 
     /**
diff --git a/jdk/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java b/jdk/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java
index 01b4316fa20..20d198b46ee 100644
--- a/jdk/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java
+++ b/jdk/src/java.base/share/classes/java/lang/module/ModuleDescriptor.java
@@ -99,6 +99,7 @@ public class ModuleDescriptor
      *
      * @see ModuleDescriptor#modifiers()
      * @since 9
+     * @spec JPMS
      */
     public static enum Modifier {
         /**
diff --git a/jdk/src/java.base/share/classes/java/lang/module/ModuleFinder.java b/jdk/src/java.base/share/classes/java/lang/module/ModuleFinder.java
index 0be9d8d9eff..e0e6d883550 100644
--- a/jdk/src/java.base/share/classes/java/lang/module/ModuleFinder.java
+++ b/jdk/src/java.base/share/classes/java/lang/module/ModuleFinder.java
@@ -286,8 +286,9 @@ public interface ModuleFinder {
      *     class names of provider classes. 
      
      *
      *     
    •  If the JAR file has a {@code Main-Class} attribute in its
-     *     main manifest then its value is the module {@link
-     *     ModuleDescriptor#mainClass() main class}. 
      • 
+     *     main manifest, its value is a legal class name, and its package is
+     *     in the set of packages derived for the module, then the value is the
+     *     module {@linkplain ModuleDescriptor#mainClass() main class}. 
      
      *
      *
    * @@ -298,8 +299,7 @@ public interface ModuleFinder { * file, where the JAR file contains a {@code .class} in the top-level * directory of the JAR file, where an entry in a service configuration * file is not a legal class name or its package name is not in the set of - * packages derived for the module, or where the module main class is not - * a legal class name or its package is not in the module.

    + * packages derived for the module.

    * *

    In addition to JAR files, an implementation may also support modules * that are packaged in other implementation specific module formats. If diff --git a/jdk/src/java.base/share/classes/java/lang/module/Resolver.java b/jdk/src/java.base/share/classes/java/lang/module/Resolver.java index 6adf93f8317..a723e638abe 100644 --- a/jdk/src/java.base/share/classes/java/lang/module/Resolver.java +++ b/jdk/src/java.base/share/classes/java/lang/module/Resolver.java @@ -28,6 +28,7 @@ package java.lang.module; import java.io.PrintStream; import java.lang.module.ModuleDescriptor.Provides; import java.lang.module.ModuleDescriptor.Requires.Modifier; +import java.net.URI; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Arrays; @@ -38,10 +39,8 @@ import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.Optional; import java.util.Set; -import java.util.StringJoiner; import java.util.stream.Collectors; import jdk.internal.module.ModuleHashes; @@ -69,12 +68,10 @@ final class Resolver { // true if all automatic modules have been found private boolean haveAllAutomaticModules; - // module constraints on target platform - private String osName; - private String osArch; + // constraint on target platform + private String targetPlatform; - String osName() { return osName; } - String osArch() { return osArch; } + String targetPlatform() { return targetPlatform; } /** * @throws IllegalArgumentException if there are more than one parent and @@ -89,37 +86,23 @@ final class Resolver { this.afterFinder = afterFinder; this.traceOutput = traceOutput; - // record constraints on target platform, checking that they don't conflict + // record constraint on target platform, checking for conflicts for (Configuration parent : parents) { - String value = parent.osName(); + String value = parent.targetPlatform(); if (value != null) { - if (osName == null) { - osName = value; + if (targetPlatform == null) { + targetPlatform = value; } else { - if (!value.equals(osName)) { - failParentConflict("Operating System", osName, value); - } - } - } - value = parent.osArch(); - if (value != null) { - if (osArch == null) { - osArch = value; - } else { - if (!value.equals(osArch)) { - failParentConflict("OS architecture", osArch, value); + if (!value.equals(targetPlatform)) { + String msg = "Parents have conflicting constraints on target" + + " platform: " + targetPlatform + ", " + value; + throw new IllegalArgumentException(msg); } } } } } - private void failParentConflict(String constraint, String s1, String s2) { - String msg = "Parents have conflicting constraints on target " - + constraint + ": " + s1 + ", " + s2; - throw new IllegalArgumentException(msg); - } - /** * Resolves the given named modules. * @@ -147,8 +130,7 @@ final class Resolver { } if (isTracing()) { - trace("Root module %s located", root); - mref.location().ifPresent(uri -> trace(" (%s)", uri)); + trace("root %s", nameAndInfo(mref)); } addFoundModule(mref); @@ -180,9 +162,7 @@ final class Resolver { ModuleDescriptor other = mref.descriptor(); q.offer(other); if (isTracing()) { - trace("Automatic module %s located, required by %s", - other.name(), descriptor.name()); - mref.location().ifPresent(uri -> trace(" (%s)", uri)); + trace("%s requires %s", descriptor.name(), nameAndInfo(mref)); } }); haveAllAutomaticModules = true; @@ -213,21 +193,13 @@ final class Resolver { } } + if (isTracing() && !dn.equals("java.base")) { + trace("%s requires %s", descriptor.name(), nameAndInfo(mref)); + } + if (!nameToReference.containsKey(dn)) { addFoundModule(mref); q.offer(mref.descriptor()); - - if (isTracing()) { - String prefix; - if (mref.descriptor().isAutomatic()) { - prefix = "Automatic module"; - } else { - prefix = "Module"; - } - trace(prefix + " %s located, required by %s", - dn, descriptor.name()); - mref.location().ifPresent(uri -> trace(" (%s)", uri)); - } } } @@ -291,6 +263,13 @@ final class Resolver { do { for (ModuleDescriptor descriptor : candidateConsumers) { if (!descriptor.uses().isEmpty()) { + + // the modules that provide at least one service + Set modulesToBind = null; + if (isTracing()) { + modulesToBind = new HashSet<>(); + } + for (String service : descriptor.uses()) { Set mrefs = availableProviders.get(service); if (mrefs != null) { @@ -298,15 +277,13 @@ final class Resolver { ModuleDescriptor provider = mref.descriptor(); if (!provider.equals(descriptor)) { - trace("Module %s provides %s, used by %s", - provider.name(), service, descriptor.name()); + if (isTracing() && modulesToBind.add(provider)) { + trace("%s binds %s", descriptor.name(), + nameAndInfo(mref)); + } String pn = provider.name(); if (!nameToReference.containsKey(pn)) { - if (isTracing()) { - mref.location() - .ifPresent(uri -> trace(" (%s)", uri)); - } addFoundModule(mref); q.push(provider); } @@ -349,59 +326,31 @@ final class Resolver { if (mref instanceof ModuleReferenceImpl) { ModuleTarget target = ((ModuleReferenceImpl)mref).moduleTarget(); if (target != null) - checkTargetConstraints(mn, target); + checkTargetPlatform(mn, target); } nameToReference.put(mn, mref); } /** - * Check that the module's constraints on the target platform do not - * conflict with the constraints of other modules resolved so far or - * modules in parent configurations. + * Check that the module's constraints on the target platform does + * conflict with the constraint of other modules resolved so far. */ - private void checkTargetConstraints(String mn, ModuleTarget target) { - String value = target.osName(); + private void checkTargetPlatform(String mn, ModuleTarget target) { + String value = target.targetPlatform(); if (value != null) { - if (osName == null) { - osName = value; + if (targetPlatform == null) { + targetPlatform = value; } else { - if (!value.equals(osName)) { - failTargetConstraint(mn, target); - } - } - } - value = target.osArch(); - if (value != null) { - if (osArch == null) { - osArch = value; - } else { - if (!value.equals(osArch)) { - failTargetConstraint(mn, target); + if (!value.equals(targetPlatform)) { + findFail("Module %s has constraints on target platform (%s)" + + " that conflict with other modules: %s", mn, + value, targetPlatform); } } } } - private void failTargetConstraint(String mn, ModuleTarget target) { - String s1 = targetAsString(osName, osArch); - String s2 = targetAsString(target.osName(), target.osArch()); - findFail("Module %s has constraints on target platform (%s) that" - + " conflict with other modules: %s", mn, s1, s2); - } - - private String targetAsString(ModuleTarget target) { - return targetAsString(target.osName(), target.osArch()); - } - - private String targetAsString(String osName, String osArch) { - return new StringJoiner("-") - .add(Objects.toString(osName, "*")) - .add(Objects.toString(osArch, "*")) - .toString(); - } - - /** * Execute post-resolution checks and returns the module graph of resolved * modules as {@code Map}. The resolved modules will be in the given @@ -412,12 +361,6 @@ final class Resolver { Map> finish(Configuration cf, boolean check) { - if (isTracing()) { - trace("Result:"); - Set names = nameToReference.keySet(); - names.stream().sorted().forEach(name -> trace(" %s", name)); - } - if (check) { detectCycles(); checkHashes(); @@ -520,9 +463,8 @@ final class Resolver { findFail("Unable to compute the hash of module %s", dn); } - // skip checking the hash if the module has been patched ModuleReferenceImpl other = (ModuleReferenceImpl)mref2; - if (other != null && !other.isPatched()) { + if (other != null) { byte[] recordedHash = hashes.hashFor(dn); byte[] actualHash = other.computeHash(algorithm); if (actualHash == null) @@ -965,9 +907,17 @@ final class Resolver { private void trace(String fmt, Object ... args) { if (traceOutput != null) { - traceOutput.format("[Resolver] " + fmt, args); + traceOutput.format(fmt, args); traceOutput.println(); } } + private String nameAndInfo(ModuleReference mref) { + ModuleDescriptor descriptor = mref.descriptor(); + StringBuilder sb = new StringBuilder(descriptor.name()); + mref.location().ifPresent(uri -> sb.append(" " + uri)); + if (descriptor.isAutomatic()) + sb.append(" automatic"); + return sb.toString(); + } } diff --git a/jdk/src/java.base/share/classes/java/lang/reflect/AnnotatedElement.java b/jdk/src/java.base/share/classes/java/lang/reflect/AnnotatedElement.java index 3bc54c2856a..fd15669931b 100644 --- a/jdk/src/java.base/share/classes/java/lang/reflect/AnnotatedElement.java +++ b/jdk/src/java.base/share/classes/java/lang/reflect/AnnotatedElement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2017, 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 @@ -105,10 +105,13 @@ import sun.reflect.annotation.AnnotationType; *

    The table below summarizes which kind of annotation presence * different methods in this interface examine. * - * + *
    * + * * * + * + * * * @@ -127,6 +130,7 @@ import sun.reflect.annotation.AnnotationType; * * + * *
    Overview of kind of presence detected by different AnnotatedElement methods
    Kind of Presence
    MethodDirectly PresentIndirectly PresentPresentAssociated
    {@code T}{@link #getAnnotation(Class) getAnnotation(Class<T>)} * X
    {@code T[]}{@link #getDeclaredAnnotationsByType(Class) getDeclaredAnnotationsByType(Class<T>)} * XX
    * *

    For an invocation of {@code get[Declared]AnnotationsByType( Class < diff --git a/jdk/src/java.base/share/classes/java/lang/reflect/ReflectPermission.java b/jdk/src/java.base/share/classes/java/lang/reflect/ReflectPermission.java index df6178358df..8b34ae3b4f2 100644 --- a/jdk/src/java.base/share/classes/java/lang/reflect/ReflectPermission.java +++ b/jdk/src/java.base/share/classes/java/lang/reflect/ReflectPermission.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2017, 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 @@ -32,12 +32,16 @@ package java.lang.reflect; * provides a summary description of what the permission allows, * and discusses the risks of granting code the permission. * - * + *
    + * + * * * * * * + * + * * * * @@ -58,6 +62,7 @@ package java.lang.reflect; * help in its attempt to compromise security in the system. * * + * *
    Table shows permission target name, what the permission allows, and associated risks
    Permission Target NameWhat the Permission AllowsRisks of Allowing this Permission
    suppressAccessChecks
    * * @see java.security.Permission diff --git a/jdk/src/java.base/share/classes/java/math/BigDecimal.java b/jdk/src/java.base/share/classes/java/math/BigDecimal.java index 5feb70fec43..f0b40ffed96 100644 --- a/jdk/src/java.base/share/classes/java/math/BigDecimal.java +++ b/jdk/src/java.base/share/classes/java/math/BigDecimal.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2017, 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 @@ -120,15 +120,19 @@ import java.util.Arrays; * preferred scale for representing a result. The preferred * scale for each operation is listed in the table below. * - * + *
    * + * * + * + * * * * * * + * *
    Preferred Scales for Results of Arithmetic Operations *
    OperationPreferred Scale of Result
    Addmax(addend.scale(), augend.scale())
    Subtractmax(minuend.scale(), subtrahend.scale())
    Multiplymultiplier.scale() + multiplicand.scale()
    Dividedividend.scale() - divisor.scale()
    Square rootradicand.scale()/2
    * * These scales are the ones used by the methods which return exact diff --git a/jdk/src/java.base/share/classes/java/math/RoundingMode.java b/jdk/src/java.base/share/classes/java/math/RoundingMode.java index 042d4f5f177..79ecce36e7f 100644 --- a/jdk/src/java.base/share/classes/java/math/RoundingMode.java +++ b/jdk/src/java.base/share/classes/java/math/RoundingMode.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2017, 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 @@ -51,8 +51,9 @@ package java.math; * proper {@code MathContext}. A summary table showing the results * of these rounding operations for all rounding modes appears below. * - * + *
    * + * * * @@ -64,6 +65,8 @@ package java.math; * * * + * + * * * * @@ -75,7 +78,8 @@ package java.math; * * * - *
    Summary of Rounding Operations Under Different Rounding Modes
    Result of rounding input to one digit with the given * rounding mode
    {@code HALF_DOWN}{@code HALF_EVEN}{@code UNNECESSARY}
    5.5 6 5 6 5 6 5 6 throw {@code ArithmeticException}
    2.5 3 2 3 2 3 2 2 throw {@code ArithmeticException}
    -1.6 -2 -1 -1 -2 -2 -2 -2 throw {@code ArithmeticException}
    -2.5 -3 -2 -2 -3 -3 -2 -2 throw {@code ArithmeticException}
    -5.5 -6 -5 -5 -6 -6 -5 -6 throw {@code ArithmeticException}
    + *

    * * *

    This {@code enum} is intended to replace the integer-based @@ -100,10 +104,13 @@ public enum RoundingMode { * value. * *

    Example: - * + *
    * + * * * + * * * * @@ -114,6 +121,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode UP Examples
    Input NumberInput rounded to one digit
    with {@code UP} rounding + *
    5.5 6
    2.5 3
    1.6 2
    -1.6 -2
    -2.5 -3
    -5.5 -6
    */ UP(BigDecimal.ROUND_UP), @@ -124,10 +132,13 @@ public enum RoundingMode { * rounding mode never increases the magnitude of the calculated value. * *

    Example: - * + *
    * + * * * + * * * * @@ -138,6 +149,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode DOWN Examples
    Input NumberInput rounded to one digit
    with {@code DOWN} rounding + *
    5.5 5
    2.5 2
    1.6 1
    -1.6 -1
    -2.5 -2
    -5.5 -5
    */ DOWN(BigDecimal.ROUND_DOWN), @@ -149,10 +161,13 @@ public enum RoundingMode { * that this rounding mode never decreases the calculated value. * *

    Example: - * + *
    * + * * * + * * * * @@ -163,6 +178,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode CEILING Examples
    Input NumberInput rounded to one digit
    with {@code CEILING} rounding + *
    5.5 6
    2.5 3
    1.6 2
    -1.6 -1
    -2.5 -2
    -5.5 -5
    */ CEILING(BigDecimal.ROUND_CEILING), @@ -174,10 +190,13 @@ public enum RoundingMode { * this rounding mode never increases the calculated value. * *

    Example: - * + *
    * + * * * + * * * * @@ -188,6 +207,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode FLOOR Examples
    Input NumberInput rounded to one digit
    with {@code FLOOR} rounding + *
    5.5 5
    2.5 2
    1.6 1
    -1.6 -2
    -2.5 -3
    -5.5 -6
    */ FLOOR(BigDecimal.ROUND_FLOOR), @@ -201,10 +221,13 @@ public enum RoundingMode { * mode commonly taught at school. * *

    Example: - * + *
    * + * * * + * * * * @@ -215,6 +238,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode HALF_UP Examples
    Input NumberInput rounded to one digit
    with {@code HALF_UP} rounding + *
    5.5 6
    2.5 3
    1.6 2
    -1.6 -2
    -2.5 -3
    -5.5 -6
    */ HALF_UP(BigDecimal.ROUND_HALF_UP), @@ -227,10 +251,13 @@ public enum RoundingMode { * {@code RoundingMode.DOWN}. * *

    Example: - * + *
    * + * * * + * * * * @@ -241,6 +268,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode HALF_DOWN Examples
    Input NumberInput rounded to one digit
    with {@code HALF_DOWN} rounding + *
    5.5 5
    2.5 2
    1.6 2
    -1.6 -2
    -2.5 -2
    -5.5 -5
    */ HALF_DOWN(BigDecimal.ROUND_HALF_DOWN), @@ -260,10 +288,13 @@ public enum RoundingMode { * arithmetic in Java. * *

    Example: - * + *
    * + * * * + * * * * @@ -274,6 +305,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode HALF_EVEN Examples
    Input NumberInput rounded to one digit
    with {@code HALF_EVEN} rounding + *
    5.5 6
    2.5 2
    1.6 2
    -1.6 -2
    -2.5 -2
    -5.5 -6
    */ HALF_EVEN(BigDecimal.ROUND_HALF_EVEN), @@ -284,10 +316,13 @@ public enum RoundingMode { * specified on an operation that yields an inexact result, an * {@code ArithmeticException} is thrown. *

    Example: - * + *
    * + * * * + * * * * @@ -298,6 +333,7 @@ public enum RoundingMode { * * * + * *
    Rounding mode UNNECESSARY Examples
    Input NumberInput rounded to one digit
    with {@code UNNECESSARY} rounding + *
    5.5 throw {@code ArithmeticException}
    2.5 throw {@code ArithmeticException}
    1.6 throw {@code ArithmeticException}
    -1.6 throw {@code ArithmeticException}
    -2.5 throw {@code ArithmeticException}
    -5.5 throw {@code ArithmeticException}
    */ UNNECESSARY(BigDecimal.ROUND_UNNECESSARY); diff --git a/jdk/src/java.base/share/classes/java/net/HttpURLConnection.java b/jdk/src/java.base/share/classes/java/net/HttpURLConnection.java index 9e428e59584..448034e6225 100644 --- a/jdk/src/java.base/share/classes/java/net/HttpURLConnection.java +++ b/jdk/src/java.base/share/classes/java/net/HttpURLConnection.java @@ -54,7 +54,7 @@ import java.util.Date; * Security permissions *

    * If a security manager is installed, and if a method is called which results in an - * attempt to open a connection, the caller must possess either:- + * attempt to open a connection, the caller must possess either: *