Added session reset message and a message for unresolved dependencies while code snippet is executed

Achal1607 · Achal1607 · commit 059b66c701e6 · 2025-11-05T16:11:46.000+05:30
diff --git a/nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/CodeEval.java b/nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/CodeEval.java
@@ -28,12 +28,16 @@
 import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import jdk.jshell.DeclarationSnippet;
 import jdk.jshell.Diag;
 import jdk.jshell.EvalException;
 import jdk.jshell.JShell;
 import jdk.jshell.JShellException;
+import jdk.jshell.Snippet.SubKind;
 import jdk.jshell.SourceCodeAnalysis;
 import jdk.jshell.SnippetEvent;
+import org.eclipse.lsp4j.MessageParams;
+import org.eclipse.lsp4j.MessageType;
 import org.netbeans.modules.java.lsp.server.notebook.CellExecutionResult;
 import org.netbeans.modules.java.lsp.server.notebook.NotebookCellExecutionProgressResultParams;
 import org.netbeans.modules.java.lsp.server.notebook.NotebookCellExecutionProgressResultParams.Builder;
@@ -48,13 +52,28 @@
  */
 @NbBundle.Messages({
     "MSG_InterruptCodeCellExecSuccess=Code execution stopped successfully",
-    "MSG_InterruptCodeCellInfo=Code execution was interrupted"
+    "MSG_InterruptCodeCellInfo=Code execution was interrupted",
+    "MSG_NotebookRestartSession=Notebook session unavailable. Please restart the notebook kernel.",
+    "LBL_method=method",
+    "LBL_variable=variable",
+    "LBL_class=class",
+    "LBL_enum=enum",
+    "LBL_interface=interface",
+    "LBL_annotation=annotation interface",
+    "# {0} - declaration type and snippet name combination",
+    "# {1} - unresolved dependencies list",
+    "MSG_UnresolvedDepsRecoverableDefined=created {0}, however, it cannot be invoked or used or instantiated until {1} is declared",
+    "# {0} - declaration type and snippet name combination",
+    "# {1} - unresolved dependencies list",
+    "MSG_UnresolvedDepsRecoverableNotDefined=created {0}, however, it cannot be referenced until {1} is declared",
+    "MSG_ListCombine=, "
 })
 public class CodeEval {
 
     private static final Logger LOG = Logger.getLogger(CodeEval.class.getName());
     private static final String CODE_EXEC_INTERRUPT_SUCCESS_MESSAGE = Bundle.MSG_InterruptCodeCellExecSuccess();
     private static final String CODE_EXEC_INTERRUPTED_MESSAGE = Bundle.MSG_InterruptCodeCellInfo();
+    private static final String RESTART_NOTEBOOK_SESSION_MESSAGE = Bundle.MSG_NotebookRestartSession();
     private static final Pattern LINEBREAK = Pattern.compile("\\R");
 
     private final Map<String, RequestProcessor> codeExecMap = new ConcurrentHashMap<>();
@@ -146,6 +165,10 @@ public CompletableFuture<Boolean> evaluate(List<Object> arguments) {
         CompletableFuture<JShell> sessionFuture = NotebookSessionManager.getInstance().getSessionFuture(notebookId);
         if (sessionFuture == null) {
             LOG.warning("notebook session not found");
+            NbCodeLanguageClient client = LanguageClientInstance.getInstance().getClient();
+            if (client != null) {
+                client.showMessage(new MessageParams(MessageType.Error, RESTART_NOTEBOOK_SESSION_MESSAGE));
+            }
             return CompletableFuture.completedFuture(false);
         }
 
@@ -218,16 +241,70 @@ private RequestProcessor getCodeExec(String notebookId) {
             return new RequestProcessor("Jshell Code Evaluator for notebookId: " + id, 1, true, true);
         });
     }
-
-    private List<String> getCompilationErrors(JShell jshell, SnippetEvent event) {
+    
+    // Made package-private for easy unit test
+    List<String> getCompilationErrors(JShell jshell, SnippetEvent event) {
         List<String> compilationErrors = new ArrayList<>();
         jshell.diagnostics(event.snippet()).forEach(diag -> {
             compilationErrors.addAll(displayableDiagnostic(event.snippet().source(), diag));
         });
 
+        if (event.snippet() instanceof DeclarationSnippet) {
+            DeclarationSnippet declSnippet = (DeclarationSnippet) event.snippet();
+            List<String> unresolvedDeps = jshell.unresolvedDependencies(declSnippet).toList();
+            if (!unresolvedDeps.isEmpty()) {
+                String msg = getUnresolvedDependencyMsg(event, declSnippet, unresolvedDeps);
+                compilationErrors.add(msg);
+            }
+        }
+
         return compilationErrors;
     }
 
+    private String getUnresolvedDependencyMsg(SnippetEvent event, DeclarationSnippet snippet, List<String> unresolvedDeps) {
+        String declarationType = getDeclarationType(snippet);
+        String prefix = declarationType.isEmpty()
+                ? snippet.name()
+                : declarationType + " " + snippet.name();
+
+        String dependencies = String.join(Bundle.MSG_ListCombine(), unresolvedDeps);
+
+        if (event.status().isDefined()) {
+            return Bundle.MSG_UnresolvedDepsRecoverableDefined(prefix, dependencies);
+        }
+        return Bundle.MSG_UnresolvedDepsRecoverableNotDefined(prefix, dependencies);
+    }
+
+    private String getDeclarationType(DeclarationSnippet snippet) {
+        switch (snippet.kind()) {
+            case METHOD:
+                return Bundle.LBL_method();
+            case VAR:
+                return Bundle.LBL_variable();
+            case TYPE_DECL:
+                return getTypeDeclarationType(snippet.subKind());
+            default:
+                LOG.warning("Cannot find declaration type of the snippet");
+                return "";
+        }
+    }
+
+    private String getTypeDeclarationType(SubKind subKind) {
+        switch (subKind) {
+            case CLASS_SUBKIND:
+                return Bundle.LBL_class();
+            case INTERFACE_SUBKIND:
+                return Bundle.LBL_interface();
+            case ENUM_SUBKIND:
+                return Bundle.LBL_enum();
+            case ANNOTATION_TYPE_SUBKIND:
+                return Bundle.LBL_annotation();
+            default:
+                LOG.warning("Cannot find declaration sub-type of the snippet");
+                return "";
+        }
+    }
+
     private List<String> getRuntimeErrors(SnippetEvent event) {
         List<String> runtimeErrors = new ArrayList<>();
         JShellException jshellException = event.exception();
@@ -300,7 +377,7 @@ private StringBuilder correctExceptionName(StringBuilder output, int startIndex,
         }
         return output;
     }
-    
+
     private StringBuilder printStackTrace(StringBuilder output, Throwable exception) {
         if (exception == null) {
             return output != null ? output : new StringBuilder(0);
@@ -311,17 +388,17 @@ private StringBuilder printStackTrace(StringBuilder output, Throwable exception)
             public void write(char[] cbuf, int off, int len) {
                 sb.append(cbuf, off, len);
             }
-            
+
             @Override
             public void flush() {
             }
-            
+
             @Override
             public void close() {
             }
         });
         exception.printStackTrace(stackWriter);
-        
+
         return sb;
     }
 
diff --git a/nbcode/notebooks/test/unit/src/org/netbeans/modules/nbcode/java/notebook/CodeEvalTest.java b/nbcode/notebooks/test/unit/src/org/netbeans/modules/nbcode/java/notebook/CodeEvalTest.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.netbeans.modules.nbcode.java.notebook;
+
+import org.junit.Test;
+import org.junit.Before;
+import org.junit.After;
+import static org.junit.Assert.*;
+
+import jdk.jshell.JShell;
+import jdk.jshell.Snippet;
+import jdk.jshell.SnippetEvent;
+
+import java.util.List;
+
+public class CodeEvalTest {
+
+    private JShell jshell;
+    private CodeEval instance;
+
+    @Before
+    public void setUp() {
+        jshell = JShell.create();
+        instance = CodeEval.getInstance();
+    }
+
+    @After
+    public void tearDown() {
+        if (jshell != null) {
+            jshell.close();
+        }
+    }
+
+    @Test
+    public void testGetCompilationErrors_WithSyntaxError() {
+        List<SnippetEvent> events = jshell.eval("int x = ;");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertFalse("Should have compilation errors", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_WithValidCode() {
+        List<SnippetEvent> events = jshell.eval("int x = 5;");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertTrue("Should not have compilation errors for valid code", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_WithUnresolvedDependency() {
+        List<SnippetEvent> events = jshell.eval("void testMethod() { System.out.println(undefinedVar); }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertFalse("Should have unresolved dependency error", errors.isEmpty());
+        boolean hasCannotBeMessage = false;
+        for (String error : errors) {
+            if (error.contains("cannot be")) {
+                hasCannotBeMessage = true;
+                break;
+            }
+        }
+        assertTrue("Error message should mention that it cannot be invoked/used", hasCannotBeMessage);
+    }
+
+    @Test
+    public void testGetCompilationErrors_MethodWithUnresolvedDependency() {
+        List<SnippetEvent> events = jshell.eval("int calculate() { return undefinedMethod(); }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertFalse("Should have errors for undefined method", errors.isEmpty());
+        boolean hasMethodReference = false;
+        for (String error : errors) {
+            if (error.contains("method") || error.contains("calculate")) {
+                hasMethodReference = true;
+                break;
+            }
+        }
+        assertTrue("Error should reference the method", hasMethodReference);
+    }
+
+    @Test
+    public void testGetCompilationErrors_ClassWithUnresolvedDependency() {
+        List<SnippetEvent> events = jshell.eval("class MyClass { UndefinedType field; }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertFalse("Should have errors for undefined type", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_VariableDeclaration() {
+        List<SnippetEvent> events = jshell.eval("String name = \"test\";");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertTrue("Valid variable declaration should have no errors", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_MultipleErrors() {
+        List<SnippetEvent> events = jshell.eval("int x = ; int y = ;");
+        
+        for (SnippetEvent event : events) {
+            List<String> errors = instance.getCompilationErrors(jshell, event);
+            if (event.snippet().kind() == Snippet.Kind.VAR) {
+                assertFalse("Should have compilation errors", errors.isEmpty());
+            }
+        }
+    }
+
+    @Test
+    public void testGetCompilationErrors_InterfaceDeclaration() {
+        List<SnippetEvent> events = jshell.eval("interface MyInterface { void method(); }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertTrue("Valid interface should have no errors", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_EnumDeclaration() {
+        List<SnippetEvent> events = jshell.eval("enum Color { RED, GREEN, BLUE }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertTrue("Valid enum should have no errors", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_MultipleUnresolvedDependencies() {
+        List<SnippetEvent> events = jshell.eval(
+            "void process() { undefinedVar1.toString(); undefinedVar2.toString(); }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertFalse("Should have errors for multiple dependencies", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_MethodDeclaration() {
+        List<SnippetEvent> events = jshell.eval("int add(int a, int b) { return a + b; }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertTrue("Valid method declaration should have no errors", errors.isEmpty());
+    }
+
+    @Test
+    public void testGetCompilationErrors_ClassDeclaration() {
+        List<SnippetEvent> events = jshell.eval("class Person { String name; int age; }");
+        SnippetEvent event = events.get(0);
+
+        List<String> errors = instance.getCompilationErrors(jshell, event);
+
+        assertTrue("Valid class declaration should have no errors", errors.isEmpty());
+    }
+}
