Completing record component in compact constructor throws NPE (eclipse-jdt#4132)

srikanth-sankaran · web-flow · commit 6c0c7bcd2a26 · 2025-06-23T10:40:06.000+05:30
* Fixes eclipse-jdt#4131
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ClassFile.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ClassFile.java
@@ -1619,7 +1619,7 @@ public int generateTypeAnnotationsOnCodeAttribute() {
 		for (int i = 0, max = this.codeStream.allLocalsCounter; i < max; i++) {
 			LocalVariableBinding localVariable = this.codeStream.locals[i];
 			if (localVariable.isCatchParameter()) continue;
-			LocalDeclaration declaration = localVariable.declaration;
+			AbstractVariableDeclaration declaration = localVariable.declaration;
 			if (declaration == null
 					|| (declaration.isArgument() && ((declaration.bits & ASTNode.IsUnionType) == 0))
 					|| (localVariable.initializationCount == 0)
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/apt/dispatch/BaseMessagerImpl.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/apt/dispatch/BaseMessagerImpl.java
@@ -26,12 +26,12 @@
 import org.eclipse.jdt.internal.compiler.apt.model.TypeElementImpl;
 import org.eclipse.jdt.internal.compiler.apt.model.VariableElementImpl;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Expression;
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
-import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
@@ -135,7 +135,7 @@ public static AptProblem createProblem(Kind kind, CharSequence msg, Element e,
 						}
 					} else if (binding instanceof AptSourceLocalVariableBinding){
 						AptSourceLocalVariableBinding parameterBinding = (AptSourceLocalVariableBinding) binding;
-						LocalDeclaration parameterDeclaration = parameterBinding.declaration;
+						AbstractVariableDeclaration parameterDeclaration = parameterBinding.declaration;
 						if (parameterDeclaration != null) {
 							MethodBinding methodBinding = parameterBinding.methodBinding;
 							if (methodBinding != null) {
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ASTNode.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
@@ -863,7 +863,7 @@ public static void resolveAnnotations(BlockScope scope, Annotation[] sourceAnnot
 							}
 						} else if (annotations != null) {
 							// One of the annotations at least is a SuppressWarnings annotation
-							LocalDeclaration localDeclaration = local.declaration;
+							AbstractVariableDeclaration localDeclaration = local.declaration;
 							int declarationSourceEnd = localDeclaration.declarationSourceEnd;
 							int declarationSourceStart = localDeclaration.declarationSourceStart;
 							for (int j = 0; j < length; j++) {
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/AbstractVariableDeclaration.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/AbstractVariableDeclaration.java
@@ -25,6 +25,7 @@
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.InferenceContext18;
 import org.eclipse.jdt.internal.compiler.lookup.InvocationSite;
+import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 import org.eclipse.jdt.internal.compiler.lookup.Scope;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
@@ -80,6 +81,10 @@ public InferenceContext18 freshInferenceContext(Scope scope) {
 		return null;
 	}
 
+	public boolean isArgument() {
+		return false;
+	}
+
 	@Override
 	public boolean isSuperAccess() {
 		return false;
@@ -162,6 +167,10 @@ public boolean isUnnamed(Scope scope) {
 		return this.name.length == 1 && this.name[0] == '_' && JavaFeature.UNNAMMED_PATTERNS_AND_VARS.isSupported(scope.compilerOptions().sourceLevel, scope.compilerOptions().enablePreviewFeatures);
 	}
 
+	public boolean isTypeNameVar(Scope scope) {
+		return this.type != null && this.type.isTypeNameVar(scope);
+	}
+
 	public void getAllAnnotationContexts(int targetType, List<AnnotationContext> allAnnotationContexts) {
 		// do nothing
 	}
@@ -170,6 +179,10 @@ public void getAllAnnotationContexts(int targetType, int parameterIndex, List<An
 		// do nothing
 	}
 
+	public void getAllAnnotationContexts(int targetType, LocalVariableBinding localVariable, List<AnnotationContext> allTypeAnnotationContexts) {
+		// do nothing
+	}
+
 	public abstract Binding getBinding();
 
 	public abstract void setBinding(Binding binding);
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Annotation.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Annotation.java
@@ -1079,7 +1079,7 @@ public TypeBinding resolveType(BlockScope scope) {
 							variable.tagBits &= ~TagBits.AnnotationNullMASK; // avoid secondary problems
 						}
 						if ((tagBits & TagBits.AnnotationSuppressWarnings) != 0) {
-							LocalDeclaration localDeclaration = variable.declaration;
+							AbstractVariableDeclaration localDeclaration = variable.declaration;
 							recordSuppressWarnings(scope, localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd, compilerOptions.suppressWarnings);
 						}
 						// note: defaultNullness for local declarations has been already been handled earlier by handleNonNullByDefault()
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/FakedTrackingVariable.java
@@ -265,13 +265,7 @@ else if (expression instanceof ConditionalExpression) {
 					return null;
 				// tracking var doesn't yet exist. This happens in finally block
 				// which is analyzed before the corresponding try block
-				ASTNode location = local.declaration;
-				if (location == null && local.isParameter() && local.declaringScope != null) {
-					if (local.declaringScope.referenceContext() instanceof ConstructorDeclaration cd && cd.isCompactConstructor()) {
-						TypeDeclaration referenceType = local.declaringScope.referenceType();
-						location = referenceType.binding.getRecordComponent(local.name);
-					}
-				}
+				Statement location = local.declaration;
 				local.closeTracker = new FakedTrackingVariable(local, location, flowInfo, flowContext, FlowInfo.UNKNOWN, useAnnotations);
 				if (local.isParameter()) {
 					local.closeTracker.globalClosingState |= OWNED_BY_OUTSIDE;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java
@@ -57,7 +57,6 @@
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
 import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
-import org.eclipse.jdt.internal.compiler.lookup.Scope;
 import org.eclipse.jdt.internal.compiler.lookup.TagBits;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 import org.eclipse.jdt.internal.compiler.parser.RecoveryScanner;
@@ -198,7 +197,7 @@ public int getKind() {
 		return LOCAL_VARIABLE;
 	}
 
-	// for local variables
+    @Override
 	public void getAllAnnotationContexts(int targetType, LocalVariableBinding localVariable, List<AnnotationContext> allAnnotationContexts) {
 		AnnotationCollector collector = new AnnotationCollector(this, targetType, localVariable, allAnnotationContexts);
 		this.traverseWithoutInitializer(collector, (BlockScope) null);
@@ -211,9 +210,6 @@ public void getAllAnnotationContexts(int targetType, int parameterIndex, List<An
 		this.traverse(collector, (BlockScope) null);
 	}
 
-	public boolean isArgument() {
-		return false;
-	}
 	public boolean isReceiver() {
 		return false;
 	}
@@ -517,10 +513,6 @@ public boolean isRecoveredFromLoneIdentifier() { // recovered from lonely identi
 				(this.type instanceof SingleTypeReference || (this.type instanceof QualifiedTypeReference && !(this.type instanceof ArrayQualifiedTypeReference))) && this.initialization == null && !this.type.isBaseTypeReference();
 	}
 
-	public boolean isTypeNameVar(Scope scope) {
-		return this.type != null && this.type.isTypeNameVar(scope);
-	}
-
 	@Override
 	public LocalVariableBinding getBinding() {
 		return this.binding;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Reference.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Reference.java
@@ -259,12 +259,12 @@ static void reportOnlyUselesslyReadLocal(BlockScope currentScope, LocalVariableB
 
 			if (shouldReport) {
 				// report the case of an argument that is unread except through a special operator
-				currentScope.problemReporter().unusedArgument(localBinding.declaration);
+				currentScope.problemReporter().unusedArgument((LocalDeclaration) localBinding.declaration);
 			}
 		}
 	} else {
 		// report the case of a local variable that is unread except for a special operator
-		currentScope.problemReporter().unusedLocalVariable(localBinding.declaration);
+		currentScope.problemReporter().unusedLocalVariable((LocalDeclaration) localBinding.declaration);
 	}
 }
 }
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java
@@ -213,13 +213,13 @@ String basicToString(int tab) {
 
 private void checkAndSetModifiersForVariable(LocalVariableBinding varBinding) {
 	int modifiers = varBinding.modifiers;
-	if ((modifiers & ExtraCompilerModifiers.AccAlternateModifierProblem) != 0 && varBinding.declaration != null){
+	if ((modifiers & ExtraCompilerModifiers.AccAlternateModifierProblem) != 0 && varBinding.declaration != null) {
 		problemReporter().duplicateModifierForVariable(varBinding.declaration, this instanceof MethodScope);
 	}
 	int realModifiers = modifiers & ExtraCompilerModifiers.AccJustFlag;
 
 	int unexpectedModifiers = ~ClassFileConstants.AccFinal;
-	if ((realModifiers & unexpectedModifiers) != 0 && varBinding.declaration != null){
+	if ((realModifiers & unexpectedModifiers) != 0 && varBinding.declaration != null) {
 		problemReporter().illegalModifierForVariable(varBinding.declaration, this instanceof MethodScope);
 	}
 	varBinding.modifiers = modifiers;
@@ -313,10 +313,10 @@ void computeLocalVariablePositions(int ilocal, int initOffset, CodeStream codeSt
 				&& !local.declaration.isUnnamed(local.declaringScope)) {
 
 				if (local.isCatchParameter()) {
-					problemReporter().unusedExceptionParameter(local.declaration); // report unused catch arguments
+					problemReporter().unusedExceptionParameter((LocalDeclaration) local.declaration); // report unused catch arguments
 				}
 				else {
-					problemReporter().unusedLocalVariable(local.declaration);
+					problemReporter().unusedLocalVariable((LocalDeclaration) local.declaration);
 				}
 			}
 
@@ -444,61 +444,6 @@ public final ReferenceBinding findLocalType(char[] name) {
 	return null;
 }
 
-/**
- * Returns all declarations of most specific locals containing a given position in their source range.
- * This code does not recurse in nested types.
- * Returned array may have null values at trailing indexes.
- */
-public LocalDeclaration[] findLocalVariableDeclarations(int position) {
-	// local variable init
-	int ilocal = 0, maxLocals = this.localIndex;
-	boolean hasMoreVariables = maxLocals > 0;
-	LocalDeclaration[] localDeclarations = null;
-	int declPtr = 0;
-
-	// scope init
-	int iscope = 0, maxScopes = this.subscopeCount;
-	boolean hasMoreScopes = maxScopes > 0;
-
-	// iterate scopes and variables in parallel
-	while (hasMoreVariables || hasMoreScopes) {
-		if (hasMoreScopes
-			&& (!hasMoreVariables || (this.subscopes[iscope].startIndex() <= ilocal))) {
-			// consider subscope first
-			Scope subscope = this.subscopes[iscope];
-			if (subscope.kind == Scope.BLOCK_SCOPE) { // do not dive in nested types
-				localDeclarations = ((BlockScope)subscope).findLocalVariableDeclarations(position);
-				if (localDeclarations != null) {
-					return localDeclarations;
-				}
-			}
-			hasMoreScopes = ++iscope < maxScopes;
-		} else {
-			// consider variable first
-			LocalVariableBinding local = this.locals[ilocal]; // if no local at all, will be locals[ilocal]==null
-			if (local != null && (local.modifiers & ExtraCompilerModifiers.AccOutOfFlowScope) == 0) {
-				LocalDeclaration localDecl = local.declaration;
-				if (localDecl != null) {
-					if (localDecl.declarationSourceStart <= position) {
-						if (position <= localDecl.declarationSourceEnd) {
-							if (localDeclarations == null) {
-								localDeclarations = new LocalDeclaration[maxLocals];
-							}
-							localDeclarations[declPtr++] = localDecl;
-						}
-					} else {
-						return localDeclarations;
-					}
-				}
-			}
-			hasMoreVariables = ++ilocal < maxLocals;
-			if (!hasMoreVariables && localDeclarations != null) {
-				return localDeclarations;
-			}
-		}
-	}
-	return null;
-}
 @Override
 public LocalVariableBinding findVariable(char[] variableName) {
 	int varLength = variableName.length;
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java
@@ -26,15 +26,7 @@
 import java.util.HashSet;
 import java.util.Set;
 import org.eclipse.jdt.core.compiler.CharOperation;
-import org.eclipse.jdt.internal.compiler.ast.ASTNode;
-import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
-import org.eclipse.jdt.internal.compiler.ast.Annotation;
-import org.eclipse.jdt.internal.compiler.ast.Expression;
-import org.eclipse.jdt.internal.compiler.ast.FakedTrackingVariable;
-import org.eclipse.jdt.internal.compiler.ast.Initializer;
-import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
-import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
-import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.*;
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
 
@@ -48,7 +40,7 @@ public class LocalVariableBinding extends VariableBinding {
 	public int useFlag; // for flow analysis (default is UNUSED), values < 0 indicate the number of compound uses (postIncrement or compoundAssignment)
 
 	public BlockScope declaringScope; // back-pointer to its declaring scope
-	public LocalDeclaration declaration; // for source-positions
+	public AbstractVariableDeclaration declaration; // for source-positions
 
 	public int[] initializationPCs;
 	public int initializationCount = 0;
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
@@ -329,7 +329,7 @@ public void checkUnusedParameters(MethodBinding method) {
 		if (local.useFlag == LocalVariableBinding.UNUSED &&
 				// do not report fake used variable
 				((local.declaration.bits & ASTNode.IsLocalDeclarationReachable) != 0)) { // declaration is reachable
-			problemReporter().unusedArgument(local.declaration);
+			problemReporter().unusedArgument((LocalDeclaration) local.declaration);
 		}
 	}
 }
@@ -355,7 +355,7 @@ public void computeLocalVariablePositions(int initOffset, CodeStream codeStream)
 			long sourceLevel = compilerOptions.sourceLevel;
 			boolean enablePreviewFeatures = compilerOptions.enablePreviewFeatures;
 			if (JavaFeature.UNNAMMED_PATTERNS_AND_VARS.isSupported(sourceLevel, enablePreviewFeatures)) {
-				problemReporter().unusedLambdaParameter(local.declaration);
+				problemReporter().unusedLambdaParameter((LocalDeclaration) local.declaration);
 			}
 		}
 
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
@@ -2100,7 +2100,7 @@ private MethodBinding resolveTypesWithSuspendedTempErrorHandlingPolicy(MethodBin
 			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);
+			final LocalVariableBinding implicitArgument = new SyntheticArgumentBinding(rcbs[i]);
 			implicitArgument.tagBits |= rcbs[i].tagBits & (TagBits.AnnotationNullMASK | TagBits.AnnotationOwningMASK);
 			methodDecl.scope.addLocalVariable(implicitArgument);
 			List<AnnotationBinding> propagatedAnnotations = new ArrayList<>();
diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/SyntheticArgumentBinding.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/SyntheticArgumentBinding.java
@@ -17,11 +17,11 @@
  * Specific local variable location used to:
  * - either provide emulation for outer local variables used from within innerclass constructs,
  * - or provide emulation to enclosing instances.
- * When it is mapping to an outer local variable, this actual outer local is accessible through
- * the public field #actualOuterLocalVariable.
+ * - or model compact constructor arguments
  *
- * Such a synthetic argument binding will be inserted in all constructors of local innertypes before
- * the user arguments.
+ * When it is mapping to an outer local variable, this actual outer local is accessible through
+ * the public field #actualOuterLocalVariable. Such a synthetic argument binding will be inserted
+ * in all constructors of local innertypes before the user arguments.
  */
 
 import org.eclipse.jdt.core.compiler.CharOperation;
@@ -41,7 +41,6 @@ public class SyntheticArgumentBinding extends LocalVariableBinding {
 	public Scope accessingScope; // scope from where the synth arg can be accessed
 
 	public SyntheticArgumentBinding(LocalVariableBinding actualOuterLocalVariable, Scope declaringScope) {
-
 		super(
 			CharOperation.concat(TypeConstants.SYNTHETIC_OUTER_LOCAL_PREFIX, actualOuterLocalVariable.name),
 			actualOuterLocalVariable.type,
@@ -52,7 +51,6 @@ public SyntheticArgumentBinding(LocalVariableBinding actualOuterLocalVariable, S
 	}
 
 	public SyntheticArgumentBinding(ReferenceBinding enclosingType) {
-
 		super(
 			CharOperation.concat(
 				TypeConstants.SYNTHETIC_ENCLOSING_INSTANCE_PREFIX,
@@ -61,4 +59,9 @@ public SyntheticArgumentBinding(ReferenceBinding enclosingType) {
 			ClassFileConstants.AccFinal,
 			true);
 	}
+
+	public SyntheticArgumentBinding(RecordComponentBinding rcb) {
+		super(rcb.name, rcb.type, rcb.modifiers, true);
+		this.declaration = rcb.sourceRecordComponent();
+	}
 }
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
@@ -2220,7 +2220,7 @@ public void duplicateModifierForType(SourceTypeBinding type) {
 		type.sourceStart(),
 		type.sourceEnd());
 }
-public void duplicateModifierForVariable(LocalDeclaration localDecl, boolean complainForArgument) {
+public void duplicateModifierForVariable(AbstractVariableDeclaration localDecl, boolean complainForArgument) {
 	String[] arguments = new String[] {new String(localDecl.name)};
 	this.handle(
 		complainForArgument
@@ -3139,9 +3139,9 @@ public void illegalModifierForMethod(AbstractMethodDeclaration methodDecl) {
 		methodDecl.sourceStart,
 		methodDecl.sourceEnd);
 }
-public void illegalModifierForVariable(LocalDeclaration localDecl, boolean complainAsArgument) {
+public void illegalModifierForVariable(AbstractVariableDeclaration localDecl, boolean complainAsArgument) {
 	String[] arguments = new String[] {new String(localDecl.name)};
-	int problemId = localDecl.binding.isPatternVariable() ?
+	int problemId = localDecl.getBinding().isPatternVariable() ?
 			IProblem.IllegalModifierForPatternVariable :
 			(complainAsArgument
 					? IProblem.IllegalModifierForArgument
diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests16.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CompletionTests16.java
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/InternalExtendedCompletionContext.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/InternalExtendedCompletionContext.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
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SelectionRequestor.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/SelectionRequestor.java
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/LocalVariableLocator.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/LocalVariableLocator.java

Original file line number	Diff line number	Diff line change
`@@ -863,7 +863,7 @@ public static void resolveAnnotations(BlockScope scope, Annotation[] sourceAnnot`
`863`	`863`	`}`
`864`	`864`	`} else if (annotations != null) {`
`865`	`865`	`// One of the annotations at least is a SuppressWarnings annotation`
`866`		`- LocalDeclaration localDeclaration = local.declaration;`
	`866`	`+ AbstractVariableDeclaration localDeclaration = local.declaration;`
`867`	`867`	`int declarationSourceEnd = localDeclaration.declarationSourceEnd;`
`868`	`868`	`int declarationSourceStart = localDeclaration.declarationSourceStart;`
`869`	`869`	`for (int j = 0; j < length; j++) {`
Original file line number	Diff line number	Diff line change
`@@ -1079,7 +1079,7 @@ public TypeBinding resolveType(BlockScope scope) {`
`1079`	`1079`	`variable.tagBits &= ~TagBits.AnnotationNullMASK; // avoid secondary problems`
`1080`	`1080`	`}`
`1081`	`1081`	`if ((tagBits & TagBits.AnnotationSuppressWarnings) != 0) {`
`1082`		`- LocalDeclaration localDeclaration = variable.declaration;`
	`1082`	`+ AbstractVariableDeclaration localDeclaration = variable.declaration;`
`1083`	`1083`	`recordSuppressWarnings(scope, localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd, compilerOptions.suppressWarnings);`
`1084`	`1084`	`}`
`1085`	`1085`	`// note: defaultNullness for local declarations has been already been handled earlier by handleNonNullByDefault()`
Original file line number	Diff line number	Diff line change
`@@ -259,12 +259,12 @@ static void reportOnlyUselesslyReadLocal(BlockScope currentScope, LocalVariableB`
`259`	`259`
`260`	`260`	`if (shouldReport) {`
`261`	`261`	`// report the case of an argument that is unread except through a special operator`
`262`		`- currentScope.problemReporter().unusedArgument(localBinding.declaration);`
	`262`	`+ currentScope.problemReporter().unusedArgument((LocalDeclaration) localBinding.declaration);`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`	`} else {`
`266`	`266`	`// report the case of a local variable that is unread except for a special operator`
`267`		`- currentScope.problemReporter().unusedLocalVariable(localBinding.declaration);`
	`267`	`+ currentScope.problemReporter().unusedLocalVariable((LocalDeclaration) localBinding.declaration);`
`268`	`268`	`}`
`269`	`269`	`}`
`270`	`270`	`}`