Roll up of makefile and test fix (temporary)

* likely test fix
* Copy value classes into preview directories for inclusion in jimage

Author: david-beaumont

make/CompileJavaModules.gmk

@@ -99,13 +99,16 @@ endif
 
 ################################################################################
 # Setup the main compilation
+
+COMPILATION_OUTPUTDIR := $(if $($(MODULE)_BIN), $($(MODULE)_BIN), $(JDK_OUTPUTDIR)/modules)
+
 $(eval $(call SetupJavaCompilation, $(MODULE), \
     SMALL_JAVA := false, \
     MODULE := $(MODULE), \
     SRC := $(wildcard $(MODULE_SRC_DIRS)), \
     INCLUDES := $(JDK_USER_DEFINED_FILTER), \
     FAIL_NO_SRC := $(FAIL_NO_SRC), \
-    BIN := $(if $($(MODULE)_BIN), $($(MODULE)_BIN), $(JDK_OUTPUTDIR)/modules), \
+    BIN := $(COMPILATION_OUTPUTDIR), \
     HEADERS := $(SUPPORT_OUTPUTDIR)/headers, \
     CREATE_API_DIGEST := true, \
     CLEAN := $(CLEAN), \
@@ -138,14 +141,23 @@ ifneq ($(COMPILER), bootjdk)
   MODULE_VALUECLASS_SRC_DIRS := $(call FindModuleValueClassSrcDirs, $(MODULE))
   MODULE_VALUECLASS_SOURCEPATH := $(call GetModuleValueClassSrcPath)
 
+  # Temporarily compile valueclasses into a separate directory with the form:
+  #   <tempdir>/<module>/<classpath>
+  # and then copy the class files into:
+  #   <outdir>/<module>/META-INF/preview/<classpath>
+  # We cannot compile directly into the desired directory because it's the
+  # compiler which creates the original '<module>/<classpath>/...' hierarchy.
+  VALUECLASS_OUTPUTDIR := $(SUPPORT_OUTPUTDIR)/$(VALUECLASSES_STR)
+  PREVIEW_OUTPUTDIR := $(COMPILATION_OUTPUTDIR)/$(MODULE)/META-INF/preview
+
   ifneq ($(MODULE_VALUECLASS_SRC_DIRS),)
     $(eval $(call SetupJavaCompilation, $(MODULE)-$(VALUECLASSES_STR), \
         SMALL_JAVA := false, \
         MODULE := $(MODULE), \
         SRC := $(wildcard $(MODULE_VALUECLASS_SRC_DIRS)), \
         INCLUDES := $(JDK_USER_DEFINED_FILTER), \
         FAIL_NO_SRC := $(FAIL_NO_SRC), \
-        BIN := $(SUPPORT_OUTPUTDIR)/$(VALUECLASSES_STR)/, \
+        BIN := $(VALUECLASS_OUTPUTDIR)/, \
         JAR := $(JDK_OUTPUTDIR)/lib/$(VALUECLASSES_STR)/$(MODULE)-$(VALUECLASSES_STR).jar, \
         HEADERS := $(SUPPORT_OUTPUTDIR)/headers, \
         DISABLED_WARNINGS := $(DISABLED_WARNINGS_java) preview, \
@@ -163,6 +175,14 @@ ifneq ($(COMPILER), bootjdk)
 
     TARGETS += $($(MODULE)-$(VALUECLASSES_STR))
 
+    # Restructure the class file hierarchy from <module>/<classpath>/... to <module>/META-INF/preview/<classpath>/...
+    $(PREVIEW_OUTPUTDIR)/_copy_valueclasses.marker: $($(MODULE)-$(VALUECLASSES_STR))
+		$(call MakeTargetDir)
+		$(CP) -R $(VALUECLASS_OUTPUTDIR)/$(MODULE)/. $(@D)/
+		$(TOUCH) $@
+
+    TARGETS += $(PREVIEW_OUTPUTDIR)/_copy_valueclasses.marker
+
     $(eval $(call SetupCopyFiles, $(MODULE)-copy-valueclass-jar, \
         FILES := $(JDK_OUTPUTDIR)/lib/$(VALUECLASSES_STR)/$(MODULE)-$(VALUECLASSES_STR).jar, \
         DEST := $(SUPPORT_OUTPUTDIR)/modules_libs/$(MODULE)/$(VALUECLASSES_STR), \

src/java.base/share/classes/jdk/internal/jimage/BasicImageReader.java

@@ -37,8 +37,12 @@
 import java.nio.file.StandardOpenOption;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.function.Predicate;
 import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
 import jdk.internal.jimage.decompressor.Decompressor;
 
 /**
@@ -326,6 +330,87 @@ public String[] getEntryNames() {
                         .toArray(String[]::new);
     }
 
+    /**
+     * Returns the "raw" API for accessing underlying jimage resource entries.
+     *
+     * <p>This is only meaningful for use by code dealing directly with jimage
+     * files, and cannot be used to reliably lookup resources used at runtime.
+     *
+     * <p>This API remains valid until the image reader from which it was
+     * obtained is closed.
+     */
+    // Package visible for use by ImageReader.
+    ResourceEntries getResourceEntries() {
+        return new ResourceEntries() {
+            @Override
+            public Stream<String> entryNamesIn(String module) {
+                if (module.isEmpty() || module.equals("modules") || module.equals("packages")) {
+                    throw new IllegalArgumentException("Invalid module name: " + module);
+                }
+                return IntStream.range(0, offsets.capacity())
+                        .map(offsets::get)
+                        .filter(offset -> offset != 0)
+                        // Reusing a location instance or getting the module
+                        // offset directly would save a lot of allocations here.
+                        .mapToObj(offset -> ImageLocation.readFrom(BasicImageReader.this, offset))
+                        // Reverse lookup of module offset would be faster here.
+                        .filter(loc -> module.equals(loc.getModule()))
+                        .map(ImageLocation::getFullName);
+            }
+
+            private ImageLocation getResourceLocation(String name) {
+                // Other types of invalid name just result in no entry being found.
+                if (name.startsWith("/modules/") || name.startsWith("/packages/")) {
+                    throw new IllegalArgumentException("Invalid entry name: " + name);
+                }
+                ImageLocation location = BasicImageReader.this.findLocation(name);
+                if (location == null) {
+                    throw new NoSuchElementException("No such resource entry: " + name);
+                }
+                return location;
+            }
+
+            @Override
+            public long sizeOf(String name) {
+                return getResourceLocation(name).getUncompressedSize();
+            }
+
+            @Override
+            public InputStream open(String name) {
+                return BasicImageReader.this.getResourceStream(getResourceLocation(name));
+            }
+        };
+    }
+
+    /**
+     * Returns a sorted array of all matching entry names in the jimage file.
+     *
+     * <p>Entry names are of one of the following forms:
+     * <ul>
+     *     <li>{@code "/modules/<mod-name>/path/to/class-or-resource"}
+     *     <li>{@code "/<mod-name>/path/to/directory"}
+     *     <li>{@code "/packages/<package-name>"}
+     * </ul>
+     *
+     * <p>Note that the module names {@code "modules"} or {@code "packages"} are
+     * not representable in a jimage file, so can never exist.
+     *
+     * <p>The resulting array is sorted lexicographically, and the resulting
+     * order need not match that of a breadth or depth first search.
+     *
+     * @param matcher a predicate for entry names to be returned.
+     */
+    public String[] getEntryNames(Predicate<String> matcher) {
+        int[] attributeOffsets = new int[offsets.capacity()];
+        offsets.get(attributeOffsets);
+        return IntStream.of(attributeOffsets)
+                .filter(o -> o != 0)
+                .mapToObj(o -> ImageLocation.readFrom(this, o).getFullName())
+                .filter(matcher)
+                .sorted()
+                .toArray(String[]::new);
+    }
+
     ImageLocation getLocation(int offset) {
         return ImageLocation.readFrom(this, offset);
     }

src/java.base/share/classes/jdk/internal/jimage/ImageReader.java

@@ -230,6 +230,19 @@ public ByteBuffer getResourceBuffer(Node node) {
         return reader.getResourceBuffer(node.getLocation());
     }
 
+    /**
+     * Returns the "raw" API for accessing underlying jimage resource entries.
+     *
+     * <p>This is only meaningful for use by code dealing directly with jimage
+     * files, and cannot be used to reliably lookup resources used at runtime.
+     *
+     * <p>This API remains valid until the image reader from which it was
+     * obtained is closed.
+     */
+    public ResourceEntries getResourceEntries() {
+        return reader.getResourceEntries();
+    }
+
     private static final class SharedImageReader extends BasicImageReader {
         // There are >30,000 nodes in a complete jimage tree, and even relatively
         // common tasks (e.g. starting up javac) load somewhere in the region of

src/java.base/share/classes/jdk/internal/jimage/ResourceEntries.java

@@ -0,0 +1,41 @@
+package jdk.internal.jimage;
+
+import java.io.InputStream;
+import java.util.stream.Stream;
+
+/**
+ * Accesses the underlying resource entries in a jimage file.
+ *
+ * <p>This API is designed only for use by the jlink classes, which manipulate
+ * jimage files directly. For inspection of runtime resources, it is vital that
+ * {@code previewMode} is correctly observed, making this API unsuitable.
+ *
+ * <p>This API ignores the {@code previewMode} of the {@link ImageReader} from
+ * which it is obtained, and returns an unmapped view of entries (e.g. allowing
+ * for direct access of resources in the {@code META-INF/preview/...} namespace).
+ *
+ * <p>It disallows access to resource directories (i.e. {@code "/modules/..."}
+ * or packages (i.e. {@code "/packages/..."}.
+ */
+public interface ResourceEntries {
+    /**
+     * Returns the full entry names for all resources in the given module, in
+     * random order. Entry names will always be prefixed by the given module
+     * name (e.g. "/<module-name/...").
+     */
+    Stream<String> entryNamesIn(String module);
+
+    /**
+     * Returns the (uncompressed) size of a resource given its full entry name.
+     *
+     * @throws java.util.NoSuchElementException if the resource does not exist.
+     */
+    long sizeOf(String name);
+
+    /**
+     * Returns an {@link InputStream} for a resource given its full entry name.
+     *
+     * @throws java.util.NoSuchElementException if the resource does not exist.
+     */
+    InputStream open(String name);
+}

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/Archive.java

@@ -24,6 +24,7 @@
  */
 package jdk.tools.jlink.internal;
 
+import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Path;
@@ -34,7 +35,7 @@
  * An Archive of all content, classes, resources, configuration files, and
  * other, for a module.
  */
-public interface Archive {
+public interface Archive extends Closeable {
 
     /**
      * Entry is contained in an Archive
@@ -59,11 +60,12 @@ public static enum EntryType {
         private final String path;
 
         /**
-         * Constructs an entry of the given archive
-         * @param archive archive
-         * @param path
-         * @param name an entry name that does not contain the module name
-         * @param type
+         * Constructs an entry of the given archive.
+         *
+         * @param archive the archive in which this entry exists.
+         * @param path the complete path of the entry, including the module.
+         * @param name an entry name relative to its containing module.
+         * @param type the entry type.
          */
         public Entry(Archive archive, String path, String name, EntryType type) {
             this.archive = Objects.requireNonNull(archive);
@@ -72,10 +74,6 @@ public Entry(Archive archive, String path, String name, EntryType type) {
             this.type = Objects.requireNonNull(type);
         }
 
-        public final Archive archive() {
-            return archive;
-        }
-
         public final EntryType type() {
             return type;
         }
@@ -87,6 +85,11 @@ public final String name() {
             return name;
         }
 
+        /**
+         * Returns the path of this entry.
+         */
+        public final String path() {return path;}
+
         /**
          * Returns the name representing a ResourcePoolEntry in the form of:
          *    /$MODULE/$ENTRY_NAME
@@ -134,5 +137,6 @@ public String toString() {
     /*
      * Close the archive
      */
+    @Override
     void close() throws IOException;
 }

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/ImageFileCreator.java

@@ -571,62 +571,4 @@ private static ResourcePoolManager createPoolManager(ResourcePool resultResource
         resultResources.entries().forEach(resources::add);
         return resources;
     }
-
-    /**
-     * Helper method that splits a Resource path onto 3 items: module, parent
-     * and resource name.
-     *
-     * @param path
-     * @return An array containing module, parent and name.
-     */
-    public static String[] splitPath(String path) {
-        Objects.requireNonNull(path);
-        String noRoot = path.substring(1);
-        int pkgStart = noRoot.indexOf("/");
-        String module = noRoot.substring(0, pkgStart);
-        List<String> result = new ArrayList<>();
-        result.add(module);
-        String pkg = noRoot.substring(pkgStart + 1);
-        String resName;
-        int pkgEnd = pkg.lastIndexOf("/");
-        if (pkgEnd == -1) { // No package.
-            resName = pkg;
-        } else {
-            resName = pkg.substring(pkgEnd + 1);
-        }
-
-        pkg = toPackage(pkg, false);
-        result.add(pkg);
-        result.add(resName);
-
-        String[] array = new String[result.size()];
-        return result.toArray(array);
-    }
-
-    /**
-     * Returns the path of the resource.
-     */
-    public static String resourceName(String path) {
-        Objects.requireNonNull(path);
-        String s = path.substring(1);
-        int index = s.indexOf("/");
-        return s.substring(index + 1);
-    }
-
-    public static String toPackage(String name) {
-        return toPackage(name, false);
-    }
-
-    private static String toPackage(String name, boolean log) {
-        int index = name.lastIndexOf('/');
-        if (index > 0) {
-            return name.substring(0, index).replace('/', '.');
-        } else {
-            // ## unnamed package
-            if (log) {
-                System.err.format("Warning: %s in unnamed package%n", name);
-            }
-            return "";
-        }
-    }
 }