Merge remote-tracking branch 'origin/master' into BETA_JAVA25

mpalat · mpalat · commit e8db0745e624 · 2025-05-13T11:26:28.000+05:30
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/core/compiler/IProblem.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/core/compiler/IProblem.java
@@ -2490,8 +2490,6 @@ public interface IProblem {
 	/** @since 3.22 */
 	int SwitchExpressionsReturnWithinSwitchExpression  = Syntax + 1724;
 
-	/* Java 14 errors end */
-	/* Java 15 errors begin */
 	/* records - begin */
 
 	/** @since 3.26 */
@@ -2597,8 +2595,6 @@ public interface IProblem {
 	 */
 	int SafeVarargsOnSyntheticRecordAccessor = TypeRelated + 1764;
 
-
-	/* records - end */
 	/* Local and Nested Static Declarations - Begin */
 	/** @since 3.28 */
 	int LocalStaticsIllegalVisibilityModifierForInterfaceLocalType = TypeRelated + 1765;
@@ -2610,6 +2606,8 @@ public interface IProblem {
 	int RecordErasureIncompatibilityInCanonicalConstructor = TypeRelated + 1768;
 	/** @since 3.41 */
 	int CompactConstructorOnlyInRecords = TypeRelated + 1769;
+	/** @since 3.42 */
+	int RecordAccessorMissingOverrideAnnotation = TypeRelated + 1770;
 	/* records - end */
 
 
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java
@@ -118,21 +118,32 @@ public void abort(int abortLevel, CategorizedProblem problem) {
 		return this.arguments; // overridden in compact constructor.
 	}
 
+	public LocalVariableBinding [] argumentBindings() {
+		int length = this.arguments == null ? 0 : this.arguments.length;
+		LocalVariableBinding [] argumentBindings = new LocalVariableBinding[length];
+		for(int i = 0; i < length; i++)
+			argumentBindings[i] = this.arguments[i].binding;
+		return argumentBindings;
+	}
+
 	/**
 	 * When a method is accessed via SourceTypeBinding.resolveTypesFor(MethodBinding)
 	 * we create the argument binding and resolve annotations in order to compute null annotation tagbits.
 	 */
 	public void createArgumentBindings() {
-		createArgumentBindings(this.arguments, this.binding, this.scope);
+		createArgumentBindings(this.arguments(true), this.binding, this.scope);
 	}
 	// version for invocation from LambdaExpression:
-	static void createArgumentBindings(Argument[] arguments, MethodBinding binding, MethodScope scope) {
+	static void createArgumentBindings(AbstractVariableDeclaration[] arguments, MethodBinding binding, MethodScope scope) {
 		boolean useTypeAnnotations = scope.environment().usesNullTypeAnnotations();
 		if (arguments != null && binding != null) {
-			for (int i = 0, length = arguments.length; i < length; i++) {
-				Argument argument = arguments[i];
-				binding.parameters[i] = argument.createBinding(scope, binding.parameters[i]);
-				long argumentTagBits = argument.binding.tagBits;
+			LocalVariableBinding [] argumentBindings = binding.isCompactConstructor() ? scope.argumentBindings() : new LocalVariableBinding[arguments.length];
+			int length = Math.min(binding.parameters.length, arguments.length);
+			for (int i = 0; i < length; i++) {
+				if (arguments[i] instanceof Argument argument)
+					argumentBindings[i] = argument.createBinding(scope, binding.parameters[i]);
+				binding.parameters[i] = argumentBindings[i].type;
+				long argumentTagBits = argumentBindings[i].tagBits;
 				if ((argumentTagBits & TagBits.AnnotationOwning) != 0) {
 					if (binding.parameterFlowBits == null) {
 						binding.parameterFlowBits = new byte[arguments.length];
@@ -245,15 +256,16 @@ public void bindThrownExceptions() {
 	 * <li>NotOwning - for resource leak analysis
 	 * </ul>
 	 */
-	static void analyseArguments(LookupEnvironment environment, FlowInfo flowInfo, FlowContext flowContext, Argument[] methodArguments, MethodBinding methodBinding) {
+	static void analyseArguments(LookupEnvironment environment, FlowInfo flowInfo, FlowContext flowContext, AbstractVariableDeclaration[] methodArguments, MethodBinding methodBinding, MethodScope scope) {
 		if (methodArguments != null) {
 			boolean usesNullTypeAnnotations = environment.usesNullTypeAnnotations();
 			boolean usesOwningAnnotations = environment.usesOwningAnnotations();
 
+			LocalVariableBinding [] methodArgumentBindings = scope.argumentBindings();
 			int length = Math.min(methodBinding.parameters.length, methodArguments.length);
 			for (int i = 0; i < length; i++) {
 				TypeBinding parameterBinding = methodBinding.parameters[i];
-				LocalVariableBinding local = methodArguments[i].binding;
+				LocalVariableBinding local = methodArgumentBindings[i];
 				if (usesNullTypeAnnotations) {
 					// leverage null type annotations:
 					long tagBits = parameterBinding.tagBits & TagBits.AnnotationNullMASK;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Argument.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Argument.java
@@ -64,7 +64,7 @@ public boolean isRecoveredFromLoneIdentifier() {
 		return false;
 	}
 
-	public TypeBinding createBinding(MethodScope scope, TypeBinding typeBinding) {
+	public LocalVariableBinding createBinding(MethodScope scope, TypeBinding typeBinding) {
 		if (this.binding == null) {
 			// for default constructors and fake implementation of abstract methods
 			this.binding = new LocalVariableBinding(this, typeBinding, this.modifiers, scope);
@@ -85,15 +85,15 @@ public TypeBinding createBinding(MethodScope scope, TypeBinding typeBinding) {
 			scope.validateNullAnnotation(this.binding.tagBits, this.type, annots);
 		}
 		this.binding.declaration = this;
-		return this.binding.type; // might have been updated during resolveAnnotations (for typeAnnotations)
+		return this.binding; // type might have been updated during resolveAnnotations (for typeAnnotations)
 	}
 
 	public TypeBinding bind(MethodScope scope, TypeBinding typeBinding, boolean used) {
 		if (this.isUnnamed(scope) && !scope.isLambdaScope()) {
 			scope.problemReporter().illegalUseOfUnderscoreAsAnIdentifier(this.sourceStart, this.sourceEnd, scope.compilerOptions().sourceLevel > ClassFileConstants.JDK1_8, true);
 		}
 
-		TypeBinding newTypeBinding = createBinding(scope, typeBinding); // basically a no-op if createBinding() was called before
+		TypeBinding newTypeBinding = createBinding(scope, typeBinding).type; // basically a no-op if createBinding() was called before
 
 		// record the resolved type into the type reference
 		Binding existingVariable = scope.getBinding(this.name, Binding.VARIABLE, this, false /*do not resolve hidden field*/);
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java
@@ -197,14 +197,7 @@ public void analyseCode(ClassScope classScope, InitializationFlowContext initial
 			}
 
 			// nullity, owning and mark as assigned
-			analyseArguments(classScope.environment(), flowInfo, initializerFlowContext, this.arguments, this.binding);
-
-			if (this.isCompactConstructor()) {
-				for (LocalVariableBinding local : this.scope.locals) {
-					if (local != null && local.isParameter())
-						flowInfo.markAsDefinitelyAssigned(local);
-				}
-			}
+			analyseArguments(classScope.environment(), flowInfo, initializerFlowContext, this.arguments(true), this.binding, this.scope);
 
 			if (JavaFeature.FLEXIBLE_CONSTRUCTOR_BODIES.matchesCompliance(this.scope.compilerOptions())) {
 				this.scope.enterEarlyConstructionContext();
@@ -301,6 +294,11 @@ public AbstractVariableDeclaration[] arguments(boolean includedElided) {
 	return includedElided && this.isCompactConstructor() ? this.protoArguments : super.arguments(includedElided);
 }
 
+@Override
+public LocalVariableBinding[] argumentBindings() {
+	return this.isCompactConstructor() ? this.scope == null ? Binding.NO_ARGUMENT_BINDINGS : this.scope.argumentBindings() : super.argumentBindings();
+}
+
 protected void doFieldReachAnalysis(FlowInfo flowInfo, FieldBinding[] fields) {
 	for (FieldBinding field : fields) {
 		if (!field.isStatic() && !flowInfo.isDefinitelyAssigned(field)) {
@@ -710,6 +708,9 @@ public void resolve(ClassScope upperScope) {
 
 	if (this.binding != null && this.binding.isCanonicalConstructor()) {
 		RecordComponentBinding[] rcbs = upperScope.referenceContext.binding.components();
+		boolean lastComponentVarargs = rcbs.length > 0 && rcbs[rcbs.length - 1].sourceRecordComponent().isVarArgs();
+		if (this.binding.isVarargs() != lastComponentVarargs)
+			upperScope.problemReporter().recordErasureIncompatibilityInCanonicalConstructor(this.arguments[this.arguments.length - 1].type);
 		for (int i = 0; i < rcbs.length; ++i) {
 			TypeBinding mpt = this.binding.parameters[i];
 			TypeBinding rct = rcbs[i].type;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
@@ -569,7 +569,7 @@ public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, fi
 
 		// nullity, owning and mark as assigned
 		MethodBinding methodWithParameterDeclaration = argumentsTypeElided() ? this.descriptor : this.binding;
-		AbstractMethodDeclaration.analyseArguments(currentScope.environment(), lambdaInfo, flowContext, this.arguments, methodWithParameterDeclaration);
+		AbstractMethodDeclaration.analyseArguments(currentScope.environment(), lambdaInfo, flowContext, this.arguments, methodWithParameterDeclaration, this.scope);
 
 		if (this.arguments != null) {
 			for (Argument argument : this.arguments) {
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java
@@ -104,7 +104,7 @@ public void analyseCode(ClassScope classScope, FlowContext flowContext, FlowInfo
 					FlowInfo.DEAD_END);
 
 			// nullity, owning and mark as assigned
-			analyseArguments(classScope.environment(), flowInfo, flowContext, this.arguments, this.binding);
+			analyseArguments(classScope.environment(), flowInfo, flowContext, this.arguments, this.binding, this.scope);
 
 			BiPredicate<TypeBinding, ReferenceBinding> condition = (argType, declClass) -> {
 				ReferenceBinding enclosingType = argType.enclosingType();
@@ -288,6 +288,9 @@ public void resolveStatements() {
 					this.scope.problemReporter().recordAccessorMethodShouldBePublic(this);
 				if (this.binding.isStatic())
 					this.scope.problemReporter().recordAccessorMethodShouldNotBeStatic(this);
+				if ((this.binding.modifiers & ExtraCompilerModifiers.AccOverriding) == 0) {
+					this.scope.problemReporter().recordAccessorMissingOverrideAnnotation(this);
+				}
 			}
 			if (this.thrownExceptions != null)
 				this.scope.problemReporter().recordAccessorMethodHasThrowsClause(this);
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java
@@ -60,7 +60,6 @@ public class ExceptionHandlingFlowContext extends FlowContext {
 	// for dealing with anonymous constructor thrown exceptions
 	public List<TypeBinding> extendedExceptions;
 
-	private static final Argument[] NO_ARGUMENTS = new Argument[0];
 	public  Argument [] catchArguments;
 
 	private final int[] exceptionToCatchBlockMap;
@@ -72,7 +71,7 @@ public ExceptionHandlingFlowContext(
 			FlowContext initializationParent,
 			BlockScope scope,
 			UnconditionalFlowInfo flowInfo) {
-	this(parent, associatedNode, handledExceptions, null, NO_ARGUMENTS, initializationParent, scope, flowInfo);
+	this(parent, associatedNode, handledExceptions, null, ASTNode.NO_ARGUMENTS, initializationParent, scope, flowInfo);
 }
 public ExceptionHandlingFlowContext(
 		FlowContext parent,
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/Binding.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/Binding.java
@@ -70,6 +70,8 @@ public abstract class Binding {
 	public static final ElementValuePair[] NO_ELEMENT_VALUE_PAIRS = new ElementValuePair[0];
 	public static final char[][] NO_PARAMETER_NAMES = new char[0][];
 	public static final RecordComponentBinding[] NO_COMPONENTS = new RecordComponentBinding[0];
+	public static final LocalVariableBinding[] NO_ARGUMENT_BINDINGS = new LocalVariableBinding[0];
+
 
 	public static final RecordComponentBinding[] UNINITIALIZED_COMPONENTS = new RecordComponentBinding[0];
 	public static final FieldBinding[] UNINITIALIZED_FIELDS = new FieldBinding[0];
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
@@ -519,6 +519,7 @@ protected void fillInDefaultNonNullness(AbstractMethodDeclaration sourceMethod,
 		this.parameterFlowBits = new byte[this.parameters.length];
 	boolean added = false;
 	int length = this.parameterFlowBits.length;
+	LocalVariableBinding [] argumentBindings = sourceMethod == null ? Binding.NO_ARGUMENT_BINDINGS : sourceMethod.argumentBindings();
 	for (int i = 0; i < length; i++) {
 		if(!needToApplyParameterNonNullDefault.hasNonNullDefaultForParam(i)) {
 			continue;
@@ -530,10 +531,11 @@ protected void fillInDefaultNonNullness(AbstractMethodDeclaration sourceMethod,
 			added = true;
 			this.parameterFlowBits[i] |= PARAM_NONNULL;
 			if (sourceMethod != null) {
-				sourceMethod.arguments[i].binding.tagBits |= TagBits.AnnotationNonNull;
+				argumentBindings[i].tagBits |= TagBits.AnnotationNonNull;
 			}
 		} else if (sourceMethod != null && (this.parameterFlowBits[i] & PARAM_NONNULL) != 0) {
-			sourceMethod.scope.problemReporter().nullAnnotationIsRedundant(sourceMethod, i);
+			if (!sourceMethod.isCompactConstructor()) // Don't complain about implicit parameter. Also component nullity applies to more than just the parameter.
+				sourceMethod.scope.problemReporter().nullAnnotationIsRedundant(sourceMethod, i);
 		}
 	}
 	if (added)
@@ -560,6 +562,7 @@ protected void fillInDefaultNonNullness18(AbstractMethodDeclaration sourceMethod
 	if (hasNonNullDefaultForParameter.hasAnyNonNullDefault()) {
 		boolean added = false;
 		int length = this.parameters.length;
+		LocalVariableBinding [] argumentBindings = sourceMethod == null ? Binding.NO_ARGUMENT_BINDINGS : sourceMethod.argumentBindings();
 		for (int i = 0; i < length; i++) {
 			if (!hasNonNullDefaultForParameter.hasNonNullDefaultForParam(i))
 				continue;
@@ -572,7 +575,7 @@ protected void fillInDefaultNonNullness18(AbstractMethodDeclaration sourceMethod
 				if (!parameter.isBaseType()) {
 					this.parameters[i] = env.createNonNullAnnotatedType(parameter);
 					if (sourceMethod != null)
-						sourceMethod.arguments[i].binding.type = this.parameters[i];
+						argumentBindings[i].type = this.parameters[i];
 				}
 			}
 		}
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java
@@ -24,6 +24,7 @@
 
 import static org.eclipse.jdt.internal.compiler.impl.JavaFeature.FLEXIBLE_CONSTRUCTOR_BODIES;
 
+import java.util.Arrays;
 import java.util.Map;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ASTVisitor;
@@ -91,6 +92,15 @@ public MethodScope(Scope parent, ReferenceContext context, boolean isStatic, int
 	this.lastVisibleFieldID = lastVisibleFieldID;
 }
 
+public LocalVariableBinding [] argumentBindings() {
+	int i = 0;
+	while (i < this.localIndex) {
+		LocalVariableBinding local = this.locals[i++];
+		if (local == null ||  !local.isParameter()) break; // done with arguments
+	}
+	return Arrays.copyOf(this.locals, i);
+}
+
 @Override
 String basicToString(int tab) {
 	String newLine = "\n"; //$NON-NLS-1$
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java
@@ -1022,7 +1022,7 @@ public RecordComponentBinding resolveTypeFor(RecordComponentBinding component) {
 		// As we resolve types for the component, patch up the corresponding instance variable
 		for (FieldBinding field : this.fields) {
 			if (CharOperation.equals(field.name, component.name)) {
-				field.type = componentType;
+				field.type = component.type;
 				field.modifiers |= component.modifiers & ExtraCompilerModifiers.AccGenericSignature;
 				field.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
 				ASTNode.copyRecordComponentAnnotations(initializationScope, field, annotations);
@@ -2258,6 +2258,7 @@ private MethodBinding resolveTypesWithSuspendedTempErrorHandlingPolicy(MethodBin
 				methodDecl.bits |= ASTNode.HasTypeAnnotations;
 			// bind the implicit argument already.
 			final LocalVariableBinding implicitArgument = new LocalVariableBinding(rcbs[i].name, rcbs[i].type, rcbs[i].modifiers, true);
+			implicitArgument.tagBits |= rcbs[i].tagBits & (TagBits.AnnotationNullMASK | TagBits.AnnotationOwningMASK);
 			methodDecl.scope.addLocalVariable(implicitArgument);
 			List<AnnotationBinding> propagatedAnnotations = new ArrayList<>();
 			ASTNode.getRelevantAnnotations(rcbs[i].sourceRecordComponent().annotations, TagBits.AnnotationForParameter, propagatedAnnotations);
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
@@ -6671,6 +6671,18 @@ public void missingOverrideAnnotation(AbstractMethodDeclaration method) {
 		method.sourceStart,
 		method.sourceEnd);
 }
+public void recordAccessorMissingOverrideAnnotation(AbstractMethodDeclaration method) {
+	int severity = computeSeverity(IProblem.MissingOverrideAnnotation);
+	if (severity == ProblemSeverities.Ignore) return;
+	MethodBinding binding = method.binding;
+	this.handle(
+		IProblem.RecordAccessorMissingOverrideAnnotation,
+		new String[] {new String(binding.selector), typesAsString(binding, false), new String(binding.declaringClass.readableName()), },
+		new String[] {new String(binding.selector), typesAsString(binding, true), new String(binding.declaringClass.shortReadableName()),},
+		severity,
+		method.sourceStart,
+		method.sourceEnd);
+}
 public void missingOverrideAnnotationForInterfaceMethodImplementation(AbstractMethodDeclaration method) {
 	int severity = computeSeverity(IProblem.MissingOverrideAnnotationForInterfaceMethodImplementation);
 	if (severity == ProblemSeverities.Ignore) return;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/messages.properties b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/messages.properties
@@ -1106,8 +1106,9 @@
 1765 = Illegal modifier for the local interface {0}; abstract and strictfp are the only modifiers allowed explicitly 
 1766 = Illegal modifier for local enum {0}; no explicit modifier is permitted
 1767 = The record {0} cannot be the superclass of {1}; a record is final and cannot be extended
-1768 = Erasure incompatibility in argument {0} of canonical constructor in record
+1768 = Type or arity incompatibility in argument {0} of canonical constructor in record class
 1769 = A canonical constructor is allowed only in record classes
+1770 = The component accessor method {0}({1}) of record class {2} should be tagged with @Override
  
 1780 = The pattern variable {0} is not in scope in this location
 1781 = The pattern variable {0} is final and cannot be assigned again
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java
@@ -1383,6 +1383,7 @@ class ProblemAttributes {
 	    expectedProblemAttributes.put("CompactConstructorOnlyInRecords", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
 	    expectedProblemAttributes.put("LocalMustBeEffectivelyFinal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
 	    expectedProblemAttributes.put("ResourceLocalMustBeEffectivelyFinal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
+	    expectedProblemAttributes.put("RecordAccessorMissingOverrideAnnotation", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
 
 	    StringBuilder failures = new StringBuilder();
 		StringBuilder correctResult = new StringBuilder(70000);
@@ -2532,6 +2533,7 @@ class ProblemAttributes {
 	    expectedProblemAttributes.put("CompactConstructorOnlyInRecords", SKIP);
 	    expectedProblemAttributes.put("LocalMustBeEffectivelyFinal", SKIP);
 	    expectedProblemAttributes.put("ResourceLocalMustBeEffectivelyFinal", SKIP);
+	    expectedProblemAttributes.put("RecordAccessorMissingOverrideAnnotation", SKIP);
 
 
 	    Map constantNamesIndex = new HashMap();
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTest.java
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/RecordsRestrictedClassTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/RecordsRestrictedClassTest.java
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests16_2.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests16_2.java
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests17.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests17.java
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ public boolean isRecoveredFromLoneIdentifier() {`
`64`	`64`	`return false;`
`65`	`65`	`}`
`66`	`66`
`67`		`- public TypeBinding createBinding(MethodScope scope, TypeBinding typeBinding) {`
	`67`	`+ public LocalVariableBinding createBinding(MethodScope scope, TypeBinding typeBinding) {`
`68`	`68`	`if (this.binding == null) {`
`69`	`69`	`// for default constructors and fake implementation of abstract methods`
`70`	`70`	`this.binding = new LocalVariableBinding(this, typeBinding, this.modifiers, scope);`
`@@ -85,15 +85,15 @@ public TypeBinding createBinding(MethodScope scope, TypeBinding typeBinding) {`
`85`	`85`	`scope.validateNullAnnotation(this.binding.tagBits, this.type, annots);`
`86`	`86`	`}`
`87`	`87`	`this.binding.declaration = this;`
`88`		`- return this.binding.type; // might have been updated during resolveAnnotations (for typeAnnotations)`
	`88`	`+ return this.binding; // type might have been updated during resolveAnnotations (for typeAnnotations)`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`public TypeBinding bind(MethodScope scope, TypeBinding typeBinding, boolean used) {`
`92`	`92`	`if (this.isUnnamed(scope) && !scope.isLambdaScope()) {`
`93`	`93`	`scope.problemReporter().illegalUseOfUnderscoreAsAnIdentifier(this.sourceStart, this.sourceEnd, scope.compilerOptions().sourceLevel > ClassFileConstants.JDK1_8, true);`
`94`	`94`	`}`
`95`	`95`
`96`		`- TypeBinding newTypeBinding = createBinding(scope, typeBinding); // basically a no-op if createBinding() was called before`
	`96`	`+ TypeBinding newTypeBinding = createBinding(scope, typeBinding).type; // basically a no-op if createBinding() was called before`
`97`	`97`
`98`	`98`	`// record the resolved type into the type reference`
`99`	`99`	`Binding existingVariable = scope.getBinding(this.name, Binding.VARIABLE, this, false /do not resolve hidden field/);`