feature: Unnamed Variables & Patterns (JEP 456) (#5848)

doc/code_elements.md

@@ -474,6 +474,19 @@ int x = switch(i) { // <-- switch expression
     int x=3;
     --x; // <-- unary --
 
+```
+### CtUnnamedPattern
+[(javadoc)](http://spoon.gforge.inria.fr/mvnsites/spoon-core/apidocs/spoon/reflect/code/CtUnnamedPattern.html)
+
+```java
+
+    Object obj = new Object();
+    record X(int i) {}
+    int i = switch (obj) {
+        case X(_) -> 0; // an unnamed pattern does neither mention a type nor a name
+        case null, default -> -1;
+    };
+
 ```
 ### CtVariableRead
 [(javadoc)](http://spoon.gforge.inria.fr/mvnsites/spoon-core/apidocs/spoon/reflect/code/CtVariableRead.html)

qodana.yaml

@@ -29,3 +29,11 @@ include:
   - name: PointlessBooleanExpression 
 exclude:
   - name: UseOfClone
+  # Do not check generated code
+  - name: All
+    paths:
+      - src/main/java/spoon/support/visitor/replace/ReplacementVisitor.java
+      - src/main/java/spoon/reflect/visitor/CtBiScannerDefault.java
+      - src/main/java/spoon/support/visitor/clone/CloneBuilder.java
+      - src/main/java/spoon/support/visitor/clone/CloneVisitor.java
+      - src/main/java/spoon/reflect/meta/impl/ModelRoleHandlers.java

spoon-smpl/src/main/java/spoon/smpl/Substitutor.java

@@ -74,6 +74,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
 import spoon.reflect.code.CtWhile;
@@ -712,6 +713,11 @@ public void visitCtRecordPattern(CtRecordPattern recordPattern) {
 		throw new NotImplementedException("Not implemented");
 	}
 
+	@Override
+	public void visitCtUnnamedPattern(CtUnnamedPattern unnamedPattern) {
+		throw new NotImplementedException("Not implemented");
+	}
+
 	@Override
 	public void visitCtReceiverParameter(CtReceiverParameter receiverParameter) {
 		throw new NotImplementedException("Not implemented");

spoon-smpl/src/main/java/spoon/smpl/pattern/PatternBuilder.java

@@ -72,6 +72,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
 import spoon.reflect.code.CtWhile;
@@ -852,6 +853,11 @@ public void visitCtRecordPattern(CtRecordPattern recordPattern) {
 		throw new NotImplementedException("Not implemented");
 	}
 
+	@Override
+	public void visitCtUnnamedPattern(CtUnnamedPattern unnamedPattern) {
+		throw new NotImplementedException("Not implemented");
+	}
+
 	@Override
 	public void visitCtReceiverParameter(CtReceiverParameter receiverParameter) {
 		throw new NotImplementedException("Not implemented");

src/main/java/spoon/metamodel/Metamodel.java

@@ -128,6 +128,7 @@ public static Set<CtType<?>> getAllMetamodelInterfaces() {
 		result.add(factory.Type().get(spoon.reflect.code.CtTypeAccess.class));
 		result.add(factory.Type().get(spoon.reflect.code.CtTypePattern.class));
 		result.add(factory.Type().get(spoon.reflect.code.CtUnaryOperator.class));
+		result.add(factory.Type().get(spoon.reflect.code.CtUnnamedPattern.class));
 		result.add(factory.Type().get(spoon.reflect.code.CtVariableAccess.class));
 		result.add(factory.Type().get(spoon.reflect.code.CtVariableRead.class));
 		result.add(factory.Type().get(spoon.reflect.code.CtVariableWrite.class));

src/main/java/spoon/reflect/code/CtCatchVariable.java

@@ -39,6 +39,12 @@ public interface CtCatchVariable<T> extends CtVariable<T>, CtMultiTypedElement,
 	@UnsettableProperty
 	<C extends CtVariable<T>> C setDefaultExpression(CtExpression<T> assignedExpression);
 
+	/**
+	 * {@return whether this catch variable is <a href="https://openjdk.org/jeps/456">unnamed</a>}
+	 */
+	@DerivedProperty
+	boolean isUnnamed();
+
 	/**
 	 * Returns type reference of the exception variable in a catch.
 	 * If type is unknown, or any of the types in a multi-catch is unknown, returns null.

src/main/java/spoon/reflect/code/CtLocalVariable.java

@@ -38,15 +38,32 @@
  * @see spoon.reflect.declaration.CtExecutable
  */
 public interface CtLocalVariable<T> extends CtStatement, CtVariable<T>, CtRHSReceiver<T>, CtResource<T> {
+
+	/**
+	 * The {@link #getSimpleName() simple name} of a local variable that is
+	 * <a href="https://openjdk.org/jeps/456">unnamed</a>.
+	 */
+	String UNNAMED_VARIABLE_NAME = "_";
+
 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see spoon.reflect.declaration.CtNamedElement#getReference()
 	 */
+	/**
+	 * {@inheritDoc}
+	 * If the variable is <a href="https://openjdk.org/jeps/456">unnamed</a>, {@code null} is returned.
+	 */
 	@Override
 	@DerivedProperty
 	CtLocalVariableReference<T> getReference();
 
+	/**
+	 * {@return whether this local variable is <a href="https://openjdk.org/jeps/456">unnamed</a>}
+	 */
+	@DerivedProperty
+	boolean isUnnamed();
+
 	/**
 	 * Useful proxy to {@link #getDefaultExpression()}.
 	 */

src/main/java/spoon/reflect/code/CtUnnamedPattern.java

@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: (MIT OR CECILL-C)
+ *
+ * Copyright (C) 2006-2023 INRIA and contributors
+ *
+ * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) or the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
+ */
+package spoon.reflect.code;
+
+import spoon.reflect.reference.CtTypeReference;
+import spoon.support.UnsettableProperty;
+
+import java.util.List;
+
+/**
+ * This code element defines an unnamed pattern, introduced in Java 2
+ * by <a href=https://openjdk.java.net/jeps/394>JEP 456</a>.
+ * <p>
+ * Example:
+ * <pre>
+ *     Object obj = new Object();
+ *     record X(int i) {}
+ *     int i = switch (obj) {
+ *         case X(_) -> 0; // an unnamed pattern does neither mention a type nor a name
+ *         case null, default -> -1;
+ *     };
+ * </pre>
+ */
+public interface CtUnnamedPattern extends CtPattern, CtExpression<Void> {
+
+	@Override
+	CtUnnamedPattern clone();
+
+	@Override
+	@UnsettableProperty
+	List<CtTypeReference<?>> getTypeCasts();
+
+	@Override
+	@UnsettableProperty
+	<C extends CtExpression<Void>> C setTypeCasts(List<CtTypeReference<?>> types);
+
+	@Override
+	@UnsettableProperty
+	<C extends CtExpression<Void>> C addTypeCast(CtTypeReference<?> type);
+
+}

src/main/java/spoon/reflect/declaration/CtNamedElement.java

@@ -34,7 +34,7 @@ public interface CtNamedElement extends CtElement {
 	<T extends CtNamedElement> T setSimpleName(String simpleName);
 
 	/**
-	 * Returns the corresponding reference.
+	 * {@return the corresponding reference}
 	 */
 	@DerivedProperty
 	CtReference getReference();

src/main/java/spoon/reflect/declaration/CtParameter.java

@@ -60,6 +60,13 @@ public interface CtParameter<T> extends CtVariable<T>, CtShadowable {
 	@UnsettableProperty
 	<C extends CtVariable<T>> C setDefaultExpression(CtExpression<T> assignedExpression);
 
+	/**
+	 * {@return whether this parameter is <a href="https://openjdk.org/jeps/456">unnamed</a>}
+	 * Unnamed parameters are always lambda parameters.
+	 */
+	@DerivedProperty
+	boolean isUnnamed();
+
 	/**
 	 * Returns true if this parameter is a lambda parameter with type defined using the `var` keyword (since Java 11).
 	 */

src/main/java/spoon/reflect/factory/CoreFactory.java

@@ -59,6 +59,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
 import spoon.reflect.code.CtWhile;
@@ -660,4 +661,9 @@ BodyHolderSourcePosition createBodyHolderSourcePosition(
 	 * @return the created receiver parameter.
 	 */
 	CtReceiverParameter createReceiverParameter();
+
+	/**
+	 * {@return an unnamed pattern}
+	 */
+	CtUnnamedPattern createUnnamedPattern();
 }

src/main/java/spoon/reflect/visitor/CtAbstractVisitor.java

@@ -59,6 +59,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
 import spoon.reflect.code.CtWhile;
@@ -570,4 +571,9 @@ public void visitCtReceiverParameter(CtReceiverParameter receiverParameter) {
 	public void visitCtRecordPattern(CtRecordPattern recordPattern) {
 
 	}
+
+	@Override
+	public void visitCtUnnamedPattern(CtUnnamedPattern unnamedPattern) {
+
+	}
 }

src/main/java/spoon/reflect/visitor/CtBiScannerDefault.java

@@ -1119,4 +1119,15 @@ public void visitCtRecordPattern(spoon.reflect.code.CtRecordPattern recordPatter
 		biScan(spoon.reflect.path.CtRole.COMMENT, recordPattern.getComments(), other.getComments());
 		exit(recordPattern);
 	}
+
+	// autogenerated by CtBiScannerGenerator
+	@java.lang.Override
+	public void visitCtUnnamedPattern(spoon.reflect.code.CtUnnamedPattern unnamedPattern) {
+		spoon.reflect.code.CtUnnamedPattern other = ((spoon.reflect.code.CtUnnamedPattern) (this.stack.peek()));
+		enter(unnamedPattern);
+		biScan(spoon.reflect.path.CtRole.ANNOTATION, unnamedPattern.getAnnotations(), other.getAnnotations());
+		biScan(spoon.reflect.path.CtRole.TYPE, unnamedPattern.getType(), other.getType());
+		biScan(spoon.reflect.path.CtRole.COMMENT, unnamedPattern.getComments(), other.getComments());
+		exit(unnamedPattern);
+	}
 }

src/main/java/spoon/reflect/visitor/CtInheritanceScanner.java

@@ -71,6 +71,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableAccess;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
@@ -1132,4 +1133,13 @@ public void visitCtReceiverParameter(CtReceiverParameter e) {
 		scanCtShadowable(e);
 	}
 
+	@Override
+	public void visitCtUnnamedPattern(CtUnnamedPattern pattern) {
+		scanCtPattern(pattern);
+		scanCtExpression(pattern);
+		scanCtTypedElement(pattern);
+		scanCtCodeElement(pattern);
+		scanCtElement(pattern);
+		scanCtVisitable(pattern);
+	}
 }

src/main/java/spoon/reflect/visitor/CtScanner.java

@@ -64,6 +64,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
 import spoon.reflect.code.CtWhile;
@@ -1115,5 +1116,14 @@ public void visitCtRecordPattern(CtRecordPattern recordPattern) {
 		scan(CtRole.COMMENT, recordPattern.getComments());
 		exit(recordPattern);
 	}
+
+	@Override
+	public void visitCtUnnamedPattern(CtUnnamedPattern unnamedPattern) {
+		enter(unnamedPattern);
+		scan(CtRole.ANNOTATION, unnamedPattern.getAnnotations());
+		scan(CtRole.TYPE, unnamedPattern.getType());
+		scan(CtRole.COMMENT, unnamedPattern.getComments());
+		exit(unnamedPattern);
+	}
 }
 

src/main/java/spoon/reflect/visitor/CtVisitor.java

@@ -59,6 +59,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
 import spoon.reflect.code.CtWhile;
@@ -577,4 +578,10 @@ <T, A extends T> void visitCtOperatorAssignment(
 	 * @param receiverParameter the receiver parameter to visit.
 	 */
 	void visitCtReceiverParameter(CtReceiverParameter receiverParameter);
+
+	/**
+	 * Visits an unnamed pattern.
+	 * @param unnamedPattern the unnamed pattern to visit.
+	 */
+	void visitCtUnnamedPattern(CtUnnamedPattern unnamedPattern);
 }

src/main/java/spoon/reflect/visitor/DefaultJavaPrettyPrinter.java

@@ -70,6 +70,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableAccess;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
@@ -2383,4 +2384,9 @@ public void visitCtReceiverParameter(CtReceiverParameter receiverParameter) {
 			printer.writeSeparator("this");
 		}
 	}
+
+	@Override
+	public void visitCtUnnamedPattern(CtUnnamedPattern unnamedPattern) {
+		printer.writeKeyword(CtLocalVariable.UNNAMED_VARIABLE_NAME);
+	}
 }

src/main/java/spoon/support/DefaultCoreFactory.java

@@ -63,6 +63,7 @@
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.code.CtTypePattern;
 import spoon.reflect.code.CtUnaryOperator;
+import spoon.reflect.code.CtUnnamedPattern;
 import spoon.reflect.code.CtVariableRead;
 import spoon.reflect.code.CtVariableWrite;
 import spoon.reflect.code.CtWhile;
@@ -165,6 +166,7 @@
 import spoon.support.reflect.code.CtTypeAccessImpl;
 import spoon.support.reflect.code.CtTypePatternImpl;
 import spoon.support.reflect.code.CtUnaryOperatorImpl;
+import spoon.support.reflect.code.CtUnnamedPatternImpl;
 import spoon.support.reflect.code.CtVariableReadImpl;
 import spoon.support.reflect.code.CtVariableWriteImpl;
 import spoon.support.reflect.code.CtWhileImpl;
@@ -1126,6 +1128,9 @@ public CtElement create(Class<? extends CtElement> klass) {
 		if (klass.equals(spoon.reflect.declaration.CtReceiverParameter.class)) {
 			return createReceiverParameter();
 		}
+		if (klass.equals(spoon.reflect.code.CtUnnamedPattern.class)) {
+			return createUnnamedPattern();
+		}
 		throw new IllegalArgumentException("not instantiable by CoreFactory(): " + klass);
 	}
 
@@ -1230,4 +1235,11 @@ public CtReceiverParameter createReceiverParameter() {
 		receiverParameter.setFactory(getMainFactory());
 		return receiverParameter;
 	}
+
+	@Override
+	public CtUnnamedPattern createUnnamedPattern() {
+		CtUnnamedPattern unnamedPattern = new CtUnnamedPatternImpl();
+		unnamedPattern.setFactory(getMainFactory());
+		return unnamedPattern;
+	}
 }