While debugging Java, 'Cannot evaluate because of compilation error(s): Evaluations must contain either an expression or a block of well-formed statements'

[prumseycsi]

Issue Type: Bug

In a Maven project, creating a TableRowSorter breaks the Debug Console evaluator.
Set a breakpoint at the indicated line in the source file. At the breakpoint, type a simple expression (e.g. "before step") in the Debug Console. It works normally. Step the statement. Type an expression again and it fails.

Extension version: 0.40.1
VS Code version: Code 1.66.2 (dfd34e8260c270da74b5c2d86d61aee4b6d56977, 2022-04-11T07:46:01.075Z)
OS version: Windows_NT x64 10.0.19044
Restricted Mode: No

Extensions (16)

Extension	Author (truncated)	Version
csharp	ms-	1.24.4
python	ms-	2022.4.1
vscode-pylance	ms-	2022.4.2
jupyter	ms-	2022.3.1000901801
jupyter-keymap	ms-	1.0.0
jupyter-renderers	ms-	1.0.6
remote-wsl	ms-	0.66.0
cpptools	ms-	1.9.8
java	red	1.5.0
vscodeintellicode	Vis	1.2.20
vscode-java-debug	vsc	0.40.1
vscode-java-dependency	vsc	0.19.1
vscode-java-pack	vsc	0.22.4
vscode-java-test	vsc	0.34.2
vscode-maven	vsc	0.35.1
omnipascal	Wos	0.19.0

.project file:

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
	<name>SlideCatalog</name>
	<comment></comment>
	<projects>
	</projects>
	<buildSpec>
		<buildCommand>
			<name>org.eclipse.jdt.core.javabuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.m2e.core.maven2Builder</name>
			<arguments>
			</arguments>
		</buildCommand>
	</buildSpec>
	<natures>
		<nature>org.eclipse.jdt.core.javanature</nature>
		<nature>org.eclipse.m2e.core.maven2Nature</nature>
	</natures>
	<filteredResources>
		<filter>
			<id>1616719244136</id>
			<name></name>
			<type>30</type>
			<matcher>
				<id>org.eclipse.core.resources.regexFilterMatcher</id>
				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
			</matcher>
		</filter>
	</filteredResources>
</projectDescription>

Source file (SlideCatalog.java, located in the src/main/java/SlideCatalog subfolder of .project's folder):

package SlideCatalog;
/*
 * SlideCatalog.java requires no other files.
 */

import javax.swing.table.*;

public class SlideCatalog
{
    public SlideCatalog() {
/*-->Set breakpoint here<--*/ TableRowSorter<MyTableModel> sorter = new TableRowSorter<>(null);
    }

    class MyTableModel extends AbstractTableModel {
        public int getColumnCount() {
            return 4;
        }

        public int getRowCount() {
            return 4;
        }

        public String getColumnName(int col) {
            return "";
        }

        public Object getValueAt(int row, int col) {
            return "";
        }

        public Class<?> getColumnClass(int c) {
            return getValueAt(0, c).getClass();
        }

    }

    public static void main(String[] args) {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new SlideCatalog();
            }
        });
    }
}

[testforstephen]

peter rumsey (@prumseycsi) Would you mind sharing a screenshot to show the snippet you evaluate and the error message you get? thanks.

[prumseycsi]

Original comment has been updated with a screenshot. Before stepping the offending statement, the string literal "before step" evaluated properly. After stepping, the string literal "after step" didn't.

[testforstephen]

Cannot reproduce it with JDK 11.

What JDK version you're using?

[prumseycsi]

That'd be Adopt OpenJDK 11.0.10+9, the only version 11 JDK that VSCode would install for me at the time (March 2021).

[clankill3r]

I have the same problem, also using OpenJDK, but I don't have a maven project.
I also upgraded to JavaSE-17 but it made no difference.

[testforstephen]

Doeke Wartena (@clankill3r) Could you please provide more details about your case? It's better to provide the snippet and a sample project?

[clankill3r]

Jinbo Wang (@testforstephen)

Ok, I boiled it down to this:

package vscode_bugged;

public class VSCode_Bugged_Example_3 {

    
public static void main(String[] args) {
    foo(tree_builder);
}


static public class Node<T extends Node<T>> {
    public T parent;
}

static public class Tree_Builder<T extends Node<T>> {
    public T current;
}

static public class Element extends Node<Element> {
    public String name;
}

static public Tree_Builder<Element> tree_builder = new Tree_Builder<>();



static public <T extends Node<T>> void foo(Tree_Builder<T> builder) {
    String s = "nope";
    if (builder.current != null) {

    }
    System.out.println(s); // breakpoint here
}

}

It might be possible to boil it down a bit further but my attempts failed so far.
So I think generics might have something to do with it as well.
Place a breakpoint on the last line (see the comment), from there you should be able to see (in the watch window!) tree_builder, builder, s and vscode_bugged.VSCode_Bugged_Example_3.tree_builder but none of them works.

This is not a maven project or the like, just VSCode_Bugged_Example_3.java being located in src/vscode_bugged.

[testforstephen]

Doeke Wartena (@clankill3r) thanks for the snippet, I can reproduce it and it's a bug. I create a new issue to track your use case. #1169

[WillsterJohnsonAtZenesis]

This is still an issue, I presume #1169 is too

In the 'variables' panel I can see this, user, and uuid all with their expected values, they also show as inlay hints in the editor, however when I open the debug console and try to access them (or to access imported classes which are used within the current method) I get the error message Evaluations must contain either an expression or a block of well-formed statements.

vscjava.vscode-java-debug v0.58.0
redhat.java v1.33.0
VSCode 1.92.0
MacOS 14.5
JDK (debugger and server) 14.0.2 (via https://cdn.azul.com/zulu/bin version zulu14.29.23-ca-jdk14.0.2-macosx_x64)
Tomcat v10.0.27

Gradle reports the following compiler args, maybe something is wrong here?

-source 14 -target 14 -d /<path-to-project>/build/classes/java/main  -h /<path-to-project>/build/generated/sources/headers/java/main -g -sourcepath <classes...> -proc:none -s /<path-to-project>/build/generated/sources/annotationProcessor/java/main -XDuseUnsharedTable=true -classpath <classes...>

While we did occasionally experience this issue in Eclipse's debugger, it was only occasionally. The workaround was just to restart the server, but that doesn't seem to work here. It happens for any expression entered, interestingly it will correctly identify when a property/method doesn't exist before it prints the error message;

Other fixes to this issue in Eclipse I've found online include;

• avoiding package/class name conflicts (eg don't use Foo.Foo)
  • we use verbose class and packages names (all packages are uk.co.* or com.*) so this isn't the issue
• ensure all Jars are in the classpath
  • doing this doesn't change the debugger behaviour

These and other solutions for eclipse don't appear to be solutions for VSCode.

Interestingly the issue only seems to appear once I step over a few expressions, but all the methods I tested are just plain java code; method calls, variable declarations, a few literals, and in one case a typecast.

Jinbo Wang (@testforstephen) is there any plan to resolve this?

[WillsterJohnsonAtZenesis]

As an experiment I've upgraded to Java 22 with the below gradle config and 22.0.2-zulu from sdkman!'s list.

java.sourceCompatibility = JavaVersion.VERSION_22
java.targetCompatibility = JavaVersion.VERSION_22

The issue persists, though it seems that it's a little better in some circumstances (this may be entirely subjective).

[github-actions]

Hi peter rumsey (@prumseycsi), I'm an AI Support assistant here to help with your issue. While the team reviews your request, I wanted to provide some possible tips and documentation that might help you in the meantime.

Issue: Debug Console evaluations fail with error:

Cannot evaluate because of compilation error(s): Evaluations must contain either an expression or a block of well-formed statements.

This occurs after stepping through code that uses generics/inner classes (e.g. TableRowSorter<MyTableModel> sorter = new TableRowSorter<>(null);).

Workarounds & Suggestions

• Upgrade to the latest Java Debugger extension and VS Code; many evaluation bugs have been fixed in newer releases.
• Try adding expressions as a watch instead of using the Debug Console.
• Wrap complex expressions in a well-formed block, for example:

  { return btDelete.getHeight(); }
  

References

• Issue #1096: Cannot evaluate because of compilation error(s). Occurs within watch expressions – similar failure when an inner class is present in method.
• Issue #781: Java Debugger not able to evaluate Java Expression in Vaadin Spring-Boot project – same evaluation error in a Spring Boot context.

Other references with low confidence

• Issue #844: Cannot evaluate because of compilation error(s): Evaluations must contain either an expression or a block of well-formed statements – failure inside a Vavr lambda expression.

The team will respond to your issue shortly. I hope these suggestions are helpful in the meantime. If this comment helped you, please give it a 👍. If the suggestion was not helpful or incorrect, please give it a 👎. Your feedback helps us improve!