Support for nested classes

Author: petrovic-d

ide/projectapi/apichanges.xml

@@ -96,10 +96,13 @@ is the proper place.
                     allow running tests in parallel.
                     <code><a href="@TOP@/org/netbeans/api/project/ContainedProjectFilter.html">ContainedProjectFilter</a></code> was added and
                     it can be used to pass list of projects the project action should apply to.
+                    <code><a href="@TOP@/org/netbeans/spi/project/NestedClass">NestedClass</a></code> was added in order to support
+                    nested classes.
                 </p>
             </description>
             <class package="org.netbeans.api.project" name="ContainedProjectFilter"/>
             <class package="org.netbeans.spi.project" name="ActionProvider"/>
+            <class package="org.netbeans.spi.project" name="NestedClass"/>
         </change>
         <change id="project-action-context">
             <api name="general"/>

ide/projectapi/src/org/netbeans/spi/project/NestedClass.java

@@ -19,38 +19,62 @@
 package org.netbeans.spi.project;
 
 import java.util.Objects;
+import org.openide.filesystems.FileObject;
 
 /**
- * Structure representing an identification of a single method/function
- * in a file.
+ * Structure representing an identification of a nested class in a file.
+ * 
+ * <p>
+ * <code>NestedClass</code> can be used to represent nested classes within parent class
+ * Example:
+ * If we have following structure: ParentClass (parent-of) ChildClass1 (parent-of) ChildClass2,
+ * for ChildClass1 className field would contain "ChildClass1", and 
+ * for ChildClass2 className field would contain "ChildClass1$ChildClass2"
+ * </p>
  * 
  * @author Dusan Petrovic
  * 
  * @since 1.90
  */
 public final class NestedClass {
 
+    private FileObject file;
     private String className;
 
     /**
      * Creates a new instance holding the specified identification
-     * of a nested class in a file.
+     * of a nested class.
      *
      * @param className name of a class inside the file
+     * @param file file to be kept in the object
      * @exception  java.lang.IllegalArgumentException
      *             if the file or class name is {@code null}
      * @since 1.90
      */
-    public NestedClass(String className) {
+    public NestedClass(String className, FileObject file) {
         super();
         if (className == null) {
             throw new IllegalArgumentException("className is <null>");
         }
+        if (file == null) {
+            throw new IllegalArgumentException("file is <null>");
+        }
         this.className = className;
+        this.file = file;
+    }
+    
+    /**
+     * Returns the file identification.
+     *
+     * @return file held by this object
+     * @since 1.90
+     */
+    public FileObject getFile() {
+        return file;
     }
 
     /**
-     * Returns name of a nested class.
+     * Returns name of a nested class within a file.
      *
      * @return class name held by this object
      * @since 1.90
@@ -63,6 +87,7 @@ public String getClassName() {
     public int hashCode() {
         int hash = 3;
         hash = 41 * hash + Objects.hashCode(this.className);
+        hash = 41 * hash + Objects.hashCode(this.file);
         return hash;
     }
 
@@ -75,6 +100,6 @@ public boolean equals(Object obj) {
             return true;
         }
         final NestedClass other = (NestedClass) obj;
-        return other.className.equals(className);
+        return other.file.equals(file) && other.className.equals(className);
     }
 }

ide/projectapi/src/org/netbeans/spi/project/SingleMethod.java

@@ -31,6 +31,7 @@ public final class SingleMethod {
 
     private FileObject file;
     private String methodName;
+    private NestedClass nestedClass;
 
     /**
      * Creates a new instance holding the specified identification
@@ -53,6 +54,37 @@ public SingleMethod(FileObject file, String methodName) {
         this.file = file;
         this.methodName = methodName;
     }
+    
+    /**
+     * Creates a new instance holding the specified identification
+     * of a method/function in nested class in a file.
+     *
+     * @param file file to be kept in the object
+     * @param methodName name of a method inside the file     
+     * @param nestedClass nested class containing the method
+     * 
+     * @exception  java.lang.IllegalArgumentException
+     *             if the nested class name is {@code null}
+     * @since 1.90
+     */
+    public SingleMethod(FileObject file, String methodName, NestedClass nestedClass) {
+        this(file, methodName);
+        if (nestedClass == null) {
+            throw new IllegalArgumentException("nestedClass is <null>");
+        }
+        this.nestedClass = nestedClass;
+    }
+    
+    
+    /**
+     * Returns the nested class containing the method.
+     *
+     * @return nested class containing the method
+     * @since 1.90
+     */
+    public NestedClass getNestedClass() {
+        return nestedClass;
+    }
 
     /**
      * Returns the file identification.
@@ -94,14 +126,15 @@ public boolean equals(Object obj) {
             return false;
         }
         SingleMethod other = (SingleMethod) obj;
-        return other.file.equals(file) && other.methodName.equals(methodName);
+        return other.file.equals(file) && other.methodName.equals(methodName) && other.nestedClass.equals(nestedClass);
     }
 
     @Override
     public int hashCode() {
         int hash = 7;
         hash = 29 * hash + this.file.hashCode();
         hash = 29 * hash + this.methodName.hashCode();
+        hash = 29 * hash + this.nestedClass.hashCode();
         return hash;
     }
 }

java/gradle.java/src/org/netbeans/modules/gradle/java/GradleJavaTokenProvider.java

@@ -34,6 +34,7 @@
 import org.netbeans.api.java.source.ClasspathInfo;
 import org.netbeans.api.java.source.SourceUtils;
 import org.netbeans.api.project.Project;
+import org.netbeans.spi.project.NestedClass;
 import org.netbeans.spi.project.SingleMethod;
 import org.openide.filesystems.FileObject;
 import org.openide.filesystems.FileUtil;
@@ -84,8 +85,9 @@ public Map<String, String> createReplacements(String action, Lookup context) {
 
     private void processSelectedPackageAndClass(final Map<String, String> map, Lookup context) {
         FileObject fo = RunUtils.extractFileObjectfromLookup(context);
+        NestedClass nestedClass = context.lookup(NestedClass.class);
         GradleJavaProject gjp = GradleJavaProject.get(project);
-        String className = evaluateClassName(gjp, fo);
+        String className = evaluateClassName(gjp, fo, nestedClass);
         if (className != null) {
             map.put(SELECTED_CLASS, className);
             int dot = className.lastIndexOf('.');
@@ -104,7 +106,8 @@ private void processSelectedMethod(final Map<String, String> map, Lookup context
         FileObject fo = method != null ? method.getFile() : RunUtils.extractFileObjectfromLookup(context);
         if ((fo != null) && fo.isData()) {
             GradleJavaProject gjp = GradleJavaProject.get(project);
-            String className = evaluateClassName(gjp, fo);
+            NestedClass nestedClass = method != null ? method.getNestedClass() : context.lookup(NestedClass.class);
+            String className = evaluateClassName(gjp, fo, nestedClass);
             String selectedMethod = method != null ? className + '.' + method.getMethodName() : className;
             map.put(SELECTED_METHOD, selectedMethod);
         }
@@ -133,7 +136,7 @@ private void processSourceSets(final Map<String, String> map, Lookup context) {
         }
     }
 
-    private String evaluateClassName(GradleJavaProject gjp, FileObject fo) {
+    private String evaluateClassName(GradleJavaProject gjp, FileObject fo, NestedClass nestedClass) {
         String ret = null;
         if ((gjp != null) && (fo != null)) {
             File f = FileUtil.toFile(fo);
@@ -145,7 +148,7 @@ private String evaluateClassName(GradleJavaProject gjp, FileObject fo) {
                         ret = relPath.replace('/', '.');
                         ret = ret + '*';
                     } else {
-                        ret = SourceUtils.classNameFor(ClasspathInfo.create(fo), relPath);
+                        ret = SourceUtils.classNameFor(ClasspathInfo.create(fo), relPath, nestedClass);
                     }
                 }
             }

java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/launch/NbLaunchDelegate.java

@@ -78,6 +78,7 @@
 import org.netbeans.spi.project.ActionProgress;
 import org.netbeans.spi.project.ActionProvider;
 import org.netbeans.api.project.ContainedProjectFilter;
+import org.netbeans.spi.project.NestedClass;
 import org.netbeans.spi.project.ProjectConfiguration;
 import org.netbeans.spi.project.ProjectConfigurationProvider;
 import org.netbeans.spi.project.SingleMethod;
@@ -126,14 +127,22 @@ protected void notifyFinished(DebugAdapterContext ctx, boolean success) {
     }
 
     public final CompletableFuture<Void> nbLaunch(FileObject toRun, boolean preferProjActions, @NullAllowed File nativeImageFile,
-                                                  @NullAllowed String method, Map<String, Object> launchArguments, DebugAdapterContext context,
+                                                  @NullAllowed String method, @NullAllowed String nestedClassName, Map<String, Object> launchArguments, DebugAdapterContext context,
                                                   boolean debug, boolean testRun, Consumer<NbProcessConsole.ConsoleMessage> consoleMessages,
                                                   boolean testInParallel) {
         CompletableFuture<Void> launchFuture = new CompletableFuture<>();
         NbProcessConsole ioContext = new NbProcessConsole(consoleMessages);
+        NestedClass nestedClass;
+        if (nestedClassName != null) {
+           nestedClass = new NestedClass(nestedClassName, toRun);
+        } else {
+            nestedClass = null;
+        }
         SingleMethod singleMethod;
         if (method != null) {
-            singleMethod = new SingleMethod(toRun, method);
+            singleMethod = nestedClass != null ?
+                    new SingleMethod(toRun, method, nestedClass)
+                    : new SingleMethod(toRun, method);
         } else {
             singleMethod = null;
         }
@@ -187,7 +196,7 @@ public void close() throws IOException {
                 }
             }
             W writer = new W();
-            CompletableFuture<Pair<ActionProvider, String>> commandFuture = findTargetWithPossibleRebuild(prj, preferProjActions, toRun, singleMethod, debug, testRun, ioContext, testInParallel, projectFilter);
+            CompletableFuture<Pair<ActionProvider, String>> commandFuture = findTargetWithPossibleRebuild(prj, preferProjActions, toRun, singleMethod, nestedClass, debug, testRun, ioContext, testInParallel, projectFilter);
             commandFuture.thenAccept((providerAndCommand) -> {
                 ExplicitProcessParameters params = createExplicitProcessParameters(launchArguments);
                 OperationContext ctx = OperationContext.find(Lookup.getDefault());
@@ -235,7 +244,7 @@ public void progressHandleCreated(ProgressOperationEvent e) {
                 }
 
                 Lookup lookup = new ProxyLookup(
-                    createTargetLookup(prj, singleMethod, toRun, projectFilter),
+                    createTargetLookup(prj, singleMethod, nestedClass, toRun, projectFilter),
                     Lookups.fixed(runContext.toArray(new Object[runContext.size()]))
                 );
                 // the execution Lookup is fully populated now. If the Project supports Configurations,
@@ -498,8 +507,8 @@ static List<String> argsToStringList(Object o) {
         }
     }
 
-    private static CompletableFuture<Pair<ActionProvider, String>> findTargetWithPossibleRebuild(Project proj, boolean preferProjActions, FileObject toRun, SingleMethod singleMethod, boolean debug, boolean testRun, NbProcessConsole ioContext, boolean testInParallel, ContainedProjectFilter projectFilter) throws IllegalArgumentException {
-        Pair<ActionProvider, String> providerAndCommand = findTarget(proj, preferProjActions, toRun, singleMethod, debug, testRun, testInParallel, projectFilter);
+    private static CompletableFuture<Pair<ActionProvider, String>> findTargetWithPossibleRebuild(Project proj, boolean preferProjActions, FileObject toRun, SingleMethod singleMethod, NestedClass nestedClass, boolean debug, boolean testRun, NbProcessConsole ioContext, boolean testInParallel, ContainedProjectFilter projectFilter) throws IllegalArgumentException {
+        Pair<ActionProvider, String> providerAndCommand = findTarget(proj, preferProjActions, toRun, singleMethod, nestedClass, debug, testRun, testInParallel, projectFilter);
         if (providerAndCommand != null) {
             return CompletableFuture.completedFuture(providerAndCommand);
         }
@@ -515,7 +524,7 @@ protected void started() {
             @Override
             public void finished(boolean success) {
                 if (success) {
-                    Pair<ActionProvider, String> providerAndCommand = findTarget(proj, preferProjActions, toRun, singleMethod, debug, testRun, testInParallel, projectFilter);
+                    Pair<ActionProvider, String> providerAndCommand = findTarget(proj, preferProjActions, toRun, singleMethod, nestedClass, debug, testRun, testInParallel, projectFilter);
                     if (providerAndCommand != null) {
                         afterBuild.complete(providerAndCommand);
                         return;
@@ -548,7 +557,7 @@ public void finished(boolean success) {
         return afterBuild;
     }
 
-    protected static @CheckForNull Pair<ActionProvider, String> findTarget(Project prj, boolean preferProjActions, FileObject toRun, SingleMethod singleMethod, boolean debug, boolean testRun, boolean testInParallel, ContainedProjectFilter projectFilter) {
+    protected static @CheckForNull Pair<ActionProvider, String> findTarget(Project prj, boolean preferProjActions, FileObject toRun, SingleMethod singleMethod, NestedClass nestedClass, boolean debug, boolean testRun, boolean testInParallel, ContainedProjectFilter projectFilter) {
         ClassPath sourceCP = ClassPath.getClassPath(toRun, ClassPath.SOURCE);
         FileObject fileRoot = sourceCP != null ? sourceCP.findOwnerRoot(toRun) : null;
         boolean mainSource;
@@ -560,7 +569,7 @@ public void finished(boolean success) {
         ActionProvider provider = null;
         String command = null;
         Collection<ActionProvider> actionProviders = findActionProviders(prj);
-        Lookup testLookup = createTargetLookup(preferProjActions ? prj : null, singleMethod, toRun, projectFilter);
+        Lookup testLookup = createTargetLookup(preferProjActions ? prj : null, singleMethod, nestedClass, toRun, projectFilter);
         String[] actions;
 
         if (testInParallel) {
@@ -577,7 +586,7 @@ public void finished(boolean success) {
                 if (debug && !mainSource) {
                     // We are calling COMMAND_DEBUG_TEST_SINGLE instead of a missing COMMAND_DEBUG_TEST
                     // This is why we need to add the file to the lookup
-                    testLookup = createTargetLookup(null, singleMethod, toRun, projectFilter);
+                    testLookup = createTargetLookup(null, singleMethod, nestedClass, toRun, projectFilter);
                 }
             } else {
                 actions = debug ? mainSource ? new String[] {ActionProvider.COMMAND_DEBUG_SINGLE}
@@ -638,7 +647,7 @@ public void invokeAction(String command, Lookup context) throws IllegalArgumentE
         return Pair.of(provider, command);
     }
 
-    static Lookup createTargetLookup(Project prj, SingleMethod singleMethod, FileObject toRun, ContainedProjectFilter projectFilter) {
+    static Lookup createTargetLookup(Project prj, SingleMethod singleMethod, NestedClass nestedClass, FileObject toRun, ContainedProjectFilter projectFilter) {
         List<Lookup> arr = new ArrayList<>();
         if (prj != null) {
             arr.add(Lookups.singleton(prj));
@@ -647,6 +656,10 @@ static Lookup createTargetLookup(Project prj, SingleMethod singleMethod, FileObj
             Lookup methodLookup = Lookups.singleton(singleMethod);
             arr.add(methodLookup);
         }
+        if (nestedClass != null) {
+            Lookup nestedClassLookup = Lookups.singleton(nestedClass);
+            arr.add(nestedClassLookup);
+        }
         if (projectFilter != null) {
             Lookup projectLookup = Lookups.singleton(projectFilter);
             arr.add(projectLookup);

java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/debugging/launch/NbLaunchRequestHandler.java

@@ -245,8 +245,9 @@ public CompletableFuture<Void> launch(Map<String, Object> launchArguments, Debug
             context.setSourcePaths((String[]) launchArguments.get("sourcePaths"));
         }
         String singleMethod = (String)launchArguments.get("methodName");
+        String nestedClass = (String)launchArguments.get("nestedClass");
         boolean testInParallel = (Boolean) launchArguments.getOrDefault("testInParallel", Boolean.FALSE);
-        activeLaunchHandler.nbLaunch(file, preferProjActions, nativeImageFile, singleMethod, launchArguments, context, !noDebug, testRun, new OutputListener(context), testInParallel).thenRun(() -> {
+        activeLaunchHandler.nbLaunch(file, preferProjActions, nativeImageFile, singleMethod, nestedClass, launchArguments, context, !noDebug, testRun, new OutputListener(context), testInParallel).thenRun(() -> {
             activeLaunchHandler.postLaunch(launchArguments, context);
             resultFuture.complete(null);
         }).exceptionally(e -> {

java/java.lsp.server/test/unit/src/org/netbeans/modules/java/lsp/server/debugging/launch/NbLaunchDelegateTest.java

@@ -43,7 +43,7 @@ public NbLaunchDelegateTest() {
     @Test
     public void testFileObjectsLookup() throws Exception {
         FileObject fo = FileUtil.createMemoryFileSystem().getRoot().createData("test.txt");
-        Lookup lkp = NbLaunchDelegate.createTargetLookup(null, null, fo, null);
+        Lookup lkp = NbLaunchDelegate.createTargetLookup(null, null, null, fo, null);
         assertEquals(fo, lkp.lookup(FileObject.class));
 
         DataObject obj = lkp.lookup(DataObject.class);
@@ -57,7 +57,7 @@ public void testFileObjectsLookup() throws Exception {
     public void testFileObjectsLookupWithSingleMethod() throws Exception {
         FileObject fo = FileUtil.createMemoryFileSystem().getRoot().createData("test-with-method.txt");
         SingleMethod m = new SingleMethod(fo, "main");
-        Lookup lkp = NbLaunchDelegate.createTargetLookup(null, m, fo, null);
+        Lookup lkp = NbLaunchDelegate.createTargetLookup(null, m, null, fo, null);
         assertEquals(fo, lkp.lookup(FileObject.class));
 
         DataObject obj = lkp.lookup(DataObject.class);
@@ -76,7 +76,7 @@ public void testFindsMavenProject() throws Exception {
         assertNotNull("Project dir recognized", prj);
 
         SingleMethod m = new SingleMethod(xml, "main");
-        Lookup lkp = NbLaunchDelegate.createTargetLookup(prj, null, null, null);
+        Lookup lkp = NbLaunchDelegate.createTargetLookup(prj, null, null, null, null);
         assertNull("No file object", lkp.lookup(FileObject.class));
         DataObject obj = lkp.lookup(DataObject.class);
         assertNull("No DataObject ", obj);
@@ -92,7 +92,7 @@ public void testFindsWithFileObjectAndDataObject() throws Exception {
         assertNotNull("Project dir recognized", prj);
 
         SingleMethod m = new SingleMethod(xml, "main");
-        Lookup lkp = NbLaunchDelegate.createTargetLookup(prj, m, xml, null);
+        Lookup lkp = NbLaunchDelegate.createTargetLookup(prj, m, null, xml, null);
         assertEquals("File object is available", xml, lkp.lookup(FileObject.class));
         DataObject obj = lkp.lookup(DataObject.class);
         assertNotNull("DataObject is available", obj);
@@ -108,7 +108,7 @@ public void testFindsWithFileObjectAndDataObjectNoMethod() throws Exception {
         Project prj = ProjectManager.getDefault().findProject(dir);
         assertNotNull("Project dir recognized", prj);
 
-        Lookup lkp = NbLaunchDelegate.createTargetLookup(prj, null, xml, null);
+        Lookup lkp = NbLaunchDelegate.createTargetLookup(prj, null, null, xml, null);
         assertEquals("File object is available", xml, lkp.lookup(FileObject.class));
         DataObject obj = lkp.lookup(DataObject.class);
         assertNotNull("DataObject is available", obj);