Alternate strategy for creation of compact constructor argument bindings (#3975)

Tasks from [Records] Follow up tasks to #3896

Author: srikanth-sankaran

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/apt/model/ExecutableElementImpl.java

@@ -22,10 +22,8 @@
 import javax.lang.model.type.TypeMirror;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.apt.dispatch.BaseProcessingEnvImpl;
-import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Argument;
-import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.lookup.*;
 
 public class ExecutableElementImpl extends ElementImpl implements
@@ -126,18 +124,11 @@ public List<? extends VariableElement> getParameters() {
 						VariableElement param = new VariableElementImpl(this._env, argument.binding);
 						params.add(param);
 					}
-				} else if (methodDeclaration.isCompactConstructor()) {
-					RecordComponentBinding[] components = binding.declaringClass.components();
-					for (int i = 0; i < length; i++) {
-						List<AnnotationBinding> relevantAnnotations = new ArrayList<>();
-						ASTNode.getRelevantAnnotations(components[i].sourceRecordComponent().annotations, TagBits.AnnotationForParameter, relevantAnnotations);
-						LocalVariableBinding pi = new LocalVariableBinding(binding.parameterNames[i], binding.parameters[i], ClassFileConstants.AccDefault, true) {
-							@Override
-							public AnnotationBinding[] getAnnotations() {
-								return relevantAnnotations.toArray(new AnnotationBinding[0]);
-							}
-						};
-						VariableElement param = new VariableElementImpl(this._env, pi);
+				} else if (methodDeclaration.isCompactConstructor()) { // can't fold if-else into one as normal argument bindings are not added to scope yet
+					for (LocalVariableBinding local : methodDeclaration.scope.locals) {
+						if (local == null || !local.isParameter())
+							continue;
+						VariableElement param = new VariableElementImpl(this._env, local);
 						params.add(param);
 					}
 				}

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java

@@ -36,7 +36,6 @@
 import static org.eclipse.jdt.internal.compiler.lookup.MethodBinding.PARAM_NULLITY;
 import static org.eclipse.jdt.internal.compiler.lookup.MethodBinding.PARAM_OWNING;
 
-import java.util.ArrayList;
 import java.util.List;
 import org.eclipse.jdt.core.compiler.CategorizedProblem;
 import org.eclipse.jdt.core.compiler.CharOperation;
@@ -173,44 +172,25 @@ public void bindArguments() {
 				}
 				return;
 			}
-		}
-
-		boolean used = this.binding == null || this.binding.isAbstract() || this.binding.isNative();
-		AnnotationBinding[][] paramAnnotations = null;
-		AbstractVariableDeclaration [] methodArguments = this.arguments != null ? this.arguments : this.isCompactConstructor() ? this.scope.referenceType().recordComponents : NO_ARGUMENTS;
-		for (int i = 0, length = methodArguments.length; i < length; i++) {
-			AbstractVariableDeclaration methodArgument = methodArguments[i];
-			AnnotationBinding [] param_i_Annotations;
-			if (methodArgument instanceof Argument argument) {
+			boolean used = this.binding.isAbstract() || this.binding.isNative();
+			AnnotationBinding[][] paramAnnotations = null;
+			for (int i = 0, length = this.arguments.length; i < length; i++) {
+				Argument argument = this.arguments[i];
 				this.binding.parameters[i] = argument.bind(this.scope, this.binding.parameters[i], used);
-				param_i_Annotations = argument.annotations != null ? argument.binding.getAnnotations() : null;
-			} else {
-				final LocalVariableBinding implicitArgument = new LocalVariableBinding(methodArgument.name, methodArgument.type.resolvedType, methodArgument.modifiers, true);
-				this.scope.addLocalVariable(implicitArgument);
-				List<AnnotationBinding> relevantAnnotationBindings = new ArrayList<>();
-				ASTNode.getRelevantAnnotations(methodArgument.annotations, TagBits.AnnotationForParameter, relevantAnnotationBindings);
-				param_i_Annotations = relevantAnnotationBindings.toArray(new AnnotationBinding[0]);
-				if (param_i_Annotations != null && param_i_Annotations.length > 0) {
-					implicitArgument.setAnnotations(param_i_Annotations, this.scope, true);
-					implicitArgument.extendedTagBits |= ExtendedTagBits.AllAnnotationsResolved;
-				}
-			}
-
-			if (param_i_Annotations != null && param_i_Annotations.length > 0) {
-				if (paramAnnotations == null) {
-					paramAnnotations = new AnnotationBinding[length][];
-					for (int j=0; j<i; j++) {
-						paramAnnotations[j] = Binding.NO_ANNOTATIONS;
+				if (argument.annotations != null) {
+					if (paramAnnotations == null) {
+						paramAnnotations = new AnnotationBinding[length][];
+						for (int j=0; j<i; j++) {
+							paramAnnotations[j] = Binding.NO_ANNOTATIONS;
+						}
 					}
+					paramAnnotations[i] = argument.binding.getAnnotations();
+				} else if (paramAnnotations != null) {
+					paramAnnotations[i] = Binding.NO_ANNOTATIONS;
 				}
-				paramAnnotations[i] = param_i_Annotations;
-			} else if (paramAnnotations != null) {
-				paramAnnotations[i] = Binding.NO_ANNOTATIONS;
 			}
-		}
-		if (paramAnnotations != null) {
-			this.binding.tagBits |= TagBits.HasParameterAnnotations;
-			this.binding.setParameterAnnotations(paramAnnotations);
+			if (paramAnnotations != null)
+				this.binding.setParameterAnnotations(paramAnnotations);
 		}
 	}
 

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java

@@ -2248,13 +2248,37 @@ private MethodBinding resolveTypesWithSuspendedTempErrorHandlingPolicy(MethodBin
 		RecordComponentBinding[] rcbs = components();
 		int length = rcbs.length;
 		method.parameters = new TypeBinding[length];
+		AnnotationBinding[][] methodsParameterAnnotations = null;
 		for (int i = 0; i < length; i++ ) {
 			method.parameters[i] = rcbs[i].type;
 			TypeBinding leafType = rcbs[i].type == null ? null : rcbs[i].type.leafComponentType();
 			if (leafType instanceof ReferenceBinding && (((ReferenceBinding) leafType).modifiers & ExtraCompilerModifiers.AccGenericSignature) != 0)
 				method.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
 			if (rcbs[i].type.hasTypeAnnotations())
 				methodDecl.bits |= ASTNode.HasTypeAnnotations;
+			// bind the implicit argument already.
+			final LocalVariableBinding implicitArgument = new LocalVariableBinding(rcbs[i].name, rcbs[i].type, rcbs[i].modifiers, true);
+			methodDecl.scope.addLocalVariable(implicitArgument);
+			List<AnnotationBinding> propagatedAnnotations = new ArrayList<>();
+			ASTNode.getRelevantAnnotations(rcbs[i].sourceRecordComponent().annotations, TagBits.AnnotationForParameter, propagatedAnnotations);
+			AnnotationBinding[] annotationsForParameter = propagatedAnnotations.toArray(new AnnotationBinding[0]);
+			if (annotationsForParameter != null && annotationsForParameter.length > 0) {
+				implicitArgument.setAnnotations(annotationsForParameter, this.scope, true);
+				implicitArgument.extendedTagBits |= ExtendedTagBits.AllAnnotationsResolved;
+				if (methodsParameterAnnotations == null) {
+					methodsParameterAnnotations = new AnnotationBinding[length][];
+					for (int j = 0; j < i; j++) {
+						methodsParameterAnnotations[j] = Binding.NO_ANNOTATIONS;
+					}
+				}
+				methodsParameterAnnotations[i] = annotationsForParameter;
+			} else if (methodsParameterAnnotations != null) {
+				methodsParameterAnnotations[i] = Binding.NO_ANNOTATIONS;
+			}
+		}
+		if (methodsParameterAnnotations != null) {
+			methodDecl.binding.tagBits |= TagBits.HasParameterAnnotations;
+			methodDecl.binding.setParameterAnnotations(methodsParameterAnnotations);
 		}
 	}