fix(lambda): Resolve Literal#constant if required. Fixes #755

src/main/java/spoon/support/compiler/jdt/JDTTreeBuilder.java

@@ -61,6 +61,7 @@
 import org.eclipse.jdt.internal.compiler.ast.IntLiteral;
 import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
 import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
+import org.eclipse.jdt.internal.compiler.ast.Literal;
 import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.LongLiteral;
 import org.eclipse.jdt.internal.compiler.ast.MarkerAnnotation;
@@ -1602,6 +1603,18 @@ public boolean visit(LocalDeclaration localDeclaration, BlockScope scope) {
 
  if (localDeclaration.initialization != null) {
  context.arguments.push(v);
+ // resolve Literal#constant if null (by calling `resolveType`). Otherwise,
+ // `localDeclaration.initialization.traverse(this, scope);` throws a
+ // NullPointerException. Fixes #755.
+ if (localDeclaration.initialization instanceof Literal
+ // exclude StringLiterals if scope is null. In other words:
+ // StringLiteral -> scope!=null <=> !StringLiteral v scope!=null.
+ && (!(localDeclaration.initialization instanceof StringLiteral) || scope != null)) {
+ final Literal literal = (Literal) localDeclaration.initialization;
+ if (literal.constant == null) {
+ literal.resolveType(scope);
+ }
+ }
  localDeclaration.initialization.traverse(this, scope);
  context.arguments.pop();
  }

src/test/java/spoon/test/literal/LiteralTest.java

@@ -29,4 +29,12 @@ public boolean matches(CtLiteral element) {
  assertEquals(':', (char) charLiteral.getValue());
  canBeBuilt("./target/literal", 8, true);
  }
+
+ @Test
+ public void testLiteralInForEachWithNoClasspath() {
+ Launcher runLaunch = new Launcher();
+ runLaunch.getEnvironment().setNoClasspath(true);
+ runLaunch.addInputResource("./src/test/resources/noclasspath/LiteralInForEach.java");
+ runLaunch.buildModel();
+ }
 }

src/test/resources/noclasspath/LiteralInForEach.java

@@ -0,0 +1,82 @@
+package noclasspath;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LiteralInForEach {
+ private static Map<String, UnknownClass> map = new HashMap<>();
+
+ public static void main(final String[] args) {
+ booleanLiteral();
+ byteLiteral();
+ shortLiteral();
+ charLiteral();
+ intLiteral();
+ floatLiteral();
+ longLiteral();
+ doubleLiteral();
+ stringLiteral();
+ }
+
+ private static void booleanLiteral() {
+ map.forEach((key, value) -> {
+ boolean b0 = true;
+ boolean b1 = false;
+ });
+ }
+
+ private static void byteLiteral() {
+ map.forEach((key, value) -> {
+ byte b = 3;
+ });
+ }
+
+ private static void shortLiteral() {
+ map.forEach((key, value) -> {
+ short s = 5;
+ });
+ }
+
+ private static void charLiteral() {
+ map.forEach((key, value) -> {
+ char c0 = 'c';
+ char c1 = 2;
+ });
+ }
+
+ private static void intLiteral() {
+ map.forEach((key, value) -> {
+ int i = 7;
+ });
+ }
+
+ private static void floatLiteral() {
+ map.forEach((key, value) -> {
+ float f0 = 9f;
+ float f1 = 9.0f;
+ });
+ }
+
+ private static void longLiteral() {
+ map.forEach((key, value) -> {
+ long l0 = 11L;
+ long l1 = 11l;
+ });
+ }
+
+ private static void doubleLiteral() {
+ map.forEach((key, value) -> {
+ double d0 = 13d;
+ double d1 = 13D;
+ double d2 = 13.0d;
+ double d3 = 13.0D;
+ double d4 = 13.0;
+ });
+ }
+
+ private static void stringLiteral() {
+ map.forEach((key, value) -> {
+ String s = "spoon";
+ });
+ }
+}