8317611: Add a tool like jdeprscan to find usage of restricted methods

src/jdk.jdeps/share/classes/com/sun/tools/jnativescan/ClassResolver.java

@@ -35,8 +35,6 @@
 import java.lang.classfile.ClassModel;
 import java.lang.constant.ClassDesc;
 import java.lang.module.ModuleDescriptor;
-import java.lang.module.ModuleFinder;
-import java.lang.module.ModuleReference;
 import java.nio.file.Path;
 import java.util.*;
 import java.util.function.BiConsumer;
@@ -119,24 +117,28 @@ private static class SystemModuleClassResolver extends ClassResolver {
 
         public SystemModuleClassResolver(JavaFileManager platformFileManager) {
             this.platformFileManager = platformFileManager;
-            this.packageToSystemModule = packageToSystemModule();
+            this.packageToSystemModule = packageToSystemModule(platformFileManager);
         }
 
-        private static Map<String, String> packageToSystemModule() {
-            List<ModuleDescriptor> descriptors = ModuleFinder.ofSystem()
-                    .findAll()
-                    .stream()
-                    .map(ModuleReference::descriptor)
-                    .toList();
-            Map<String, String> result = new HashMap<>();
-            for (ModuleDescriptor descriptor : descriptors) {
-                for (ModuleDescriptor.Exports export : descriptor.exports()) {
-                    if (!export.isQualified()) {
-                        result.put(export.source(), descriptor.name());
+        private static Map<String, String> packageToSystemModule(JavaFileManager platformFileManager) {
+            try {
+                Set<JavaFileManager.Location> locations = platformFileManager.listLocationsForModules(
+                        StandardLocation.SYSTEM_MODULES).iterator().next();
+
+                Map<String, String> result = new HashMap<>();
+                for (JavaFileManager.Location loc : locations) {
+                    JavaFileObject jfo = platformFileManager.getJavaFileForInput(loc, "module-info", JavaFileObject.Kind.CLASS);
+                    ModuleDescriptor descriptor = ModuleDescriptor.read(jfo.openInputStream());
+                    for (ModuleDescriptor.Exports export : descriptor.exports()) {
+                        if (!export.isQualified()) {
+                            result.put(export.source(), descriptor.name());
+                        }
                     }
                 }
+                return result;
+            } catch (IOException e) {
+                throw new RuntimeException(e);
             }
-            return result;
         }
 
         @Override
@@ -153,6 +155,9 @@ public Optional<Info> lookup(ClassDesc desc) {
                     try {
                         JavaFileManager.Location loc = platformFileManager.getLocationForModule(StandardLocation.SYSTEM_MODULES, moduleName);
                         JavaFileObject jfo = platformFileManager.getJavaFileForInput(loc, qualName, JavaFileObject.Kind.CLASS);
+                        if (jfo == null) {
+                            throw new JNativeScanFatalError("System class can not be found: " + qualName);
+                        }
                         ClassModel model = ClassFile.of().parse(jfo.openInputStream().readAllBytes());
                         return new Info(moduleName, null, model);
                     } catch (IOException e) {

src/jdk.jdeps/share/classes/com/sun/tools/jnativescan/JNativeScanTask.java

@@ -80,9 +80,9 @@ public void run() throws JNativeScanFatalError {
         Map<ScannedModule, Map<ClassDesc, List<RestrictedUse>>> allRestrictedMethods;
         try(ClassResolver classesToScan = ClassResolver.forScannedModules(modulesToScan, version);
                 ClassResolver systemClassResolver = ClassResolver.forSystemModules(version)) {
-            RestrictedMethodFinder finder = RestrictedMethodFinder.create(classesToScan, systemClassResolver);
+            NativeMethodFinder finder = NativeMethodFinder.create(classesToScan, systemClassResolver);
             allRestrictedMethods = finder.findAll();
-        } catch (Exception e) {
+        } catch (IOException e) {
             throw new RuntimeException(e);
         }
 

src/jdk.jdeps/share/classes/com/sun/tools/jnativescan/Main.java

@@ -75,6 +75,11 @@ public int run(String[] args) {
             parseOptionsAndRun(expandedArgs);
         } catch (JNativeScanFatalError fatalError) {
             printError(fatalError.getMessage());
+            for (Throwable cause = fatalError.getCause();
+                     cause instanceof JNativeScanFatalError jNativeScanFatalError;
+                     cause = jNativeScanFatalError.getCause()) {
+                err.println("CAUSED BY: " + jNativeScanFatalError.getMessage());
+            }
             if (DEBUG) {
                 fatalError.printStackTrace(err);
             }
@@ -122,8 +127,8 @@ private void parseOptionsAndRun(String[] expandedArgs) throws JNativeScanFatalEr
 
         if (optionSet.has(helpOpt)) {
             out.println("""
-                The jnativescan tool can be used to find methods that may access native functionalities when
-                run. This includes methods that call restricted methods, and 'native' method declarations.
+                The jnativescan tool can be used to find methods that may access native functionality when
+                run. This includes restricted method calls and 'native' method declarations.
                 """);
             try {
                 parser.printHelpOn(out);

src/jdk.jdeps/share/classes/com/sun/tools/jnativescan/MethodRef.java

@@ -25,8 +25,6 @@
 package com.sun.tools.jnativescan;
 
 import java.lang.classfile.MethodModel;
-import java.lang.classfile.constantpool.ClassEntry;
-import java.lang.classfile.constantpool.InterfaceMethodRefEntry;
 import java.lang.classfile.constantpool.MemberRefEntry;
 import java.lang.constant.ClassDesc;
 import java.lang.constant.MethodTypeDesc;
@@ -37,7 +35,7 @@ public static MethodRef ofModel(MethodModel model) {
                 model.methodName().stringValue(), model.methodTypeSymbol());
     }
 
-    public static MethodRef ofMethodRefEntry(MemberRefEntry method) {
+    public static MethodRef ofMemberRefEntry(MemberRefEntry method) {
         return new MethodRef(method.owner().asSymbol(),
                 method.name().stringValue(), MethodTypeDesc.ofDescriptor(method.type().stringValue()));
     }

src/jdk.jdeps/share/classes/com/sun/tools/jnativescan/RestrictedMethodFinder.java → src/jdk.jdeps/share/classes/com/sun/tools/jnativescan/NativeMethodFinder.java

@@ -40,24 +40,23 @@
 import java.lang.reflect.AccessFlag;
 import java.util.*;
 
-class RestrictedMethodFinder {
+class NativeMethodFinder {
 
     // ct.sym uses this fake name for the restricted annotation instead
     // see make/langtools/src/classes/build/tools/symbolgenerator/CreateSymbols.java
     private static final String RESTRICTED_NAME = "Ljdk/internal/javac/Restricted+Annotation;";
-    private static final List<String> RESTRICTED_MODULES = List.of("java.base");
 
     private final Map<MethodRef, Boolean> CACHE = new HashMap<>();
     private final ClassResolver classesToScan;
     private final ClassResolver systemClassResolver;
 
-    private RestrictedMethodFinder(ClassResolver classesToScan, ClassResolver systemClassResolver) {
+    private NativeMethodFinder(ClassResolver classesToScan, ClassResolver systemClassResolver) {
         this.classesToScan = classesToScan;
         this.systemClassResolver = systemClassResolver;
     }
 
-    public static RestrictedMethodFinder create(ClassResolver classesToScan, ClassResolver systemClassResolver) throws JNativeScanFatalError, IOException {
-        return new RestrictedMethodFinder(classesToScan, systemClassResolver);
+    public static NativeMethodFinder create(ClassResolver classesToScan, ClassResolver systemClassResolver) throws JNativeScanFatalError, IOException {
+        return new NativeMethodFinder(classesToScan, systemClassResolver);
     }
 
     public Map<ScannedModule, Map<ClassDesc, List<RestrictedUse>>> findAll() throws JNativeScanFatalError {
@@ -70,20 +69,25 @@ public Map<ScannedModule, Map<ClassDesc, List<RestrictedUse>>> findAll() throws
                     perClass.add(new NativeMethodDecl(MethodRef.ofModel(methodModel)));
                 } else {
                     Set<MethodRef> perMethod = new HashSet<>();
-                    methodModel.code()
-                        .ifPresent(code -> {
-                            code.forEach(e -> {
-                                switch (e) {
-                                    case InvokeInstruction invoke -> {
-                                        if (isRestrictedMethod(invoke.method())) {
-                                            perMethod.add(MethodRef.ofMethodRefEntry(invoke.method()));
-                                        }
-                                    }
-                                    default -> {
-                                    }
-                                }
-                            });
-                        });
+                    methodModel.code().ifPresent(code -> {
+                         try {
+                             code.forEach(e -> {
+                                 switch (e) {
+                                     case InvokeInstruction invoke -> {
+                                         MethodRef ref = MethodRef.ofMemberRefEntry(invoke.method());
+                                         if (isRestrictedMethod(ref)) {
+                                             perMethod.add(ref);
+                                         }
+                                     }
+                                     default -> {
+                                     }
+                                 }
+                             });
+                         } catch (JNativeScanFatalError e) {
+                             throw new JNativeScanFatalError("Error while processing method: " +
+                                     MethodRef.ofModel(methodModel), e);
+                         }
+                    });
                     if (!perMethod.isEmpty()) {
                         perClass.add(new RestrictedMethodRefs(MethodRef.ofModel(methodModel),
                                 Set.copyOf(perMethod)));
@@ -99,18 +103,8 @@ public Map<ScannedModule, Map<ClassDesc, List<RestrictedUse>>> findAll() throws
         return restrictedMethods;
     }
 
-    private boolean isRestrictedMethod(MemberRefEntry method) throws JNativeScanFatalError {
-        return switch (method) {
-            case MethodRefEntry mre ->
-                    isRestrictedMethod(mre.owner().asSymbol(), mre.name().stringValue(), mre.typeSymbol());
-            case InterfaceMethodRefEntry mre ->
-                    isRestrictedMethod(mre.owner().asSymbol(), mre.name().stringValue(), mre.typeSymbol());
-            default -> throw new IllegalStateException("Unexpected type: " + method);
-        };
-    }
-
-    private boolean isRestrictedMethod(ClassDesc owner, String name, MethodTypeDesc type) throws JNativeScanFatalError {
-        return CACHE.computeIfAbsent(new MethodRef(owner, name, type), methodRef -> {
+    private boolean isRestrictedMethod(MethodRef ref) throws JNativeScanFatalError {
+        return CACHE.computeIfAbsent(ref, methodRef -> {
             if (methodRef.owner().isArray()) {
                 // no restricted methods in arrays atm, and we can't look them up since they have no class file
                 return false;

src/jdk.jdeps/share/classes/module-info.java

@@ -28,12 +28,13 @@
 /**
  * Defines tools for analysing dependencies in Java libraries and programs,
  * including the <em>{@index jdeps jdeps tool}</em>,
- * <em>{@index javap javap tool}</em>, and
- * <em>{@index jdeprscan jdeprscan tool}</em> tools.
+ * <em>{@index javap javap tool}</em>,
+ * <em>{@index jdeprscan jdeprscan tool}</em>, and
+ * <em>{@index jnativescan jnativescan tool}</em> tools.
  *
  * <p>
  * This module provides the equivalent of command-line access to the
- * <em>javap</em> and <em>jdeps</em> tools via the
+ * <em>javap</em>, <em>jdeps</em>, and <em>jnativescan</em> tools via the
  * {@link java.util.spi.ToolProvider ToolProvider} service provider
  * interface (SPI)</p>
  *
@@ -49,12 +50,14 @@
  * @toolGuide javap
  * @toolGuide jdeprscan
  * @toolGuide jdeps
+ * @toolGuide jnativescan
  *
  * @provides java.util.spi.ToolProvider
- *     Use {@link java.util.spi.ToolProvider#findFirst ToolProvider.findFirst("javap")}
- *     or {@link java.util.spi.ToolProvider#findFirst ToolProvider.findFirst("jdeps")}
+ *     Use {@link java.util.spi.ToolProvider#findFirst ToolProvider.findFirst("javap")},
+ *     {@link java.util.spi.ToolProvider#findFirst ToolProvider.findFirst("jdeps")},
+ *     or {@link java.util.spi.ToolProvider#findFirst ToolProvider.findFirst("jnativescan")}
  *     to obtain an instance of a {@code ToolProvider} that provides the equivalent
- *     of command-line access to the {@code javap} or {@code jdeps} tool.
+ *     of command-line access to the {@code javap}, {@code jdeps}, {@code jnativescan} tool.
  *
  * @moduleGraph
  * @since 9