diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java index dec50d0f7a3..912b6040d32 100644 --- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java +++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java @@ -589,7 +589,7 @@ void faultInImports() { this.typeOrPackageCache = new HashtableOfObject(length); for (int i = 0; i < length; i++) { ImportBinding binding = this.imports[i]; - if (!binding.onDemand && binding.resolvedImport instanceof ReferenceBinding || binding instanceof ImportConflictBinding) + if (!binding.onDemand && binding.getResolvedBindingKind() == Binding.TYPE || binding instanceof ImportConflictBinding) this.typeOrPackageCache.put(binding.getSimpleName(), binding); } this.skipCachingImports = this.environment.suppressImportErrors && unresolvedFound; @@ -768,24 +768,34 @@ ImportBinding[] getDefaultImports() { BinaryTypeBinding missingObject = this.environment.createMissingType(null, TypeConstants.JAVA_LANG_OBJECT); importBinding = missingObject.fPackage; } - ReferenceBinding templateSTR; ImportBinding[] allImports = null; if (this.environment.globalOptions.complianceLevel >= ClassFileConstants.JDK21) { - boolean old = this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled; - this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled = false; - templateSTR = (ReferenceBinding) ((PackageBinding) importBinding).getTypeOrPackage(TypeConstants.JAVA_LANG_STRING_TEMPLATE_STR[2], module(), false); - if (templateSTR != null) { - FieldBinding str = templateSTR.getField("STR".toCharArray(), true); //$NON-NLS-1$ - ImportBinding ibinding = new ImportBinding(TypeConstants.JAVA_LANG_STRING_TEMPLATE_STR, false, str, null) { - @Override - public boolean isStatic() { - return true; + ImportBinding ibinding = new ImportBinding(TypeConstants.JAVA_LANG_STRING_TEMPLATE_STR, false, importBinding, null) { + @Override + public boolean isStatic() { + return true; + } + @Override + public int getResolvedBindingKind() { + return Binding.FIELD; // avoid resolving during faultInImports() + } + @Override + public Binding getResolvedImport() { + // resolve lazily: + Binding resolvedImport = super.getResolvedImport(); + if (resolvedImport instanceof PackageBinding) { // package was past into the constructor, need to dig deeper now: + ReferenceBinding templateSTR = (ReferenceBinding) ((PackageBinding) resolvedImport).getTypeOrPackage(TypeConstants.JAVA_LANG_STRING_TEMPLATE_STR[2], module(), false); + if (templateSTR != null) { + FieldBinding fieldBinding = templateSTR.getField("STR".toCharArray(), true); //$NON-NLS-1$ + if (fieldBinding != null) + return setResolvedImport(fieldBinding); + } } - }; - allImports = new ImportBinding[] { - new ImportBinding(TypeConstants.JAVA_LANG, true, importBinding, null), ibinding}; - } - this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled = old; + return resolvedImport; + } + }; + allImports = new ImportBinding[] { + new ImportBinding(TypeConstants.JAVA_LANG, true, importBinding, null), ibinding}; } if (allImports == null){ allImports = new ImportBinding[] {new ImportBinding(TypeConstants.JAVA_LANG, true, importBinding, null)}; @@ -936,11 +946,14 @@ void recordTypeReferences(TypeBinding[] types) { } } Binding resolveSingleImport(ImportBinding importBinding, int mask) { - if (importBinding.resolvedImport == null) { - importBinding.resolvedImport = findSingleImport(importBinding.compoundName, mask, importBinding.isStatic()); - if (!importBinding.resolvedImport.isValidBinding() || importBinding.resolvedImport instanceof PackageBinding) { - if (importBinding.resolvedImport.problemId() == ProblemReasons.Ambiguous) - return importBinding.resolvedImport; + Binding resolvedBinding = importBinding.getResolvedImport(); + if (resolvedBinding != null) { + return resolvedBinding; + } else { + resolvedBinding = importBinding.setResolvedImport(findSingleImport(importBinding.compoundName, mask, importBinding.isStatic())); + if (!resolvedBinding.isValidBinding() || resolvedBinding instanceof PackageBinding) { + if (resolvedBinding.problemId() == ProblemReasons.Ambiguous) + return resolvedBinding; if (this.imports != null) { ImportBinding[] newImports = new ImportBinding[this.imports.length - 1]; for (int i = 0, n = 0, max = this.imports.length; i < max; i++) @@ -950,8 +963,8 @@ Binding resolveSingleImport(ImportBinding importBinding, int mask) { } return null; } + return resolvedBinding; } - return importBinding.resolvedImport; } public void storeDependencyInfo() { // add the type hierarchy of each referenced supertype @@ -1109,7 +1122,7 @@ private int checkAndRecordImportBinding( recordImportBinding(new ImportBinding(compoundName, false, importBinding, importReference)); } } - } else if (resolved.resolvedImport == referenceBinding) { + } else if (resolved.getResolvedImport() == referenceBinding) { if (importReference.isStatic() != resolved.isStatic()) { recordImportBinding(new ImportBinding(compoundName, false, importBinding, importReference)); } @@ -1128,10 +1141,12 @@ private int checkAndRecordImportBinding( // 7.5.3 says nothing about collision of single static imports and JDK8 tolerates them, though use is flagged. for (int j = 0; j < this.importPtr; j++) { ImportBinding resolved = this.tempImports[j]; - if (resolved.isStatic() && resolved.resolvedImport instanceof ReferenceBinding && importBinding != resolved.resolvedImport) { + Binding resolvedImport = resolved.getResolvedImport(); + if (resolved.isStatic() + && resolvedImport instanceof ReferenceBinding type + && importBinding != resolvedImport) { if (CharOperation.equals(compoundName[compoundName.length - 1], resolved.compoundName[resolved.compoundName.length - 1])) { - ReferenceBinding type = (ReferenceBinding) resolved.resolvedImport; - resolved.resolvedImport = new ProblemReferenceBinding(new char[][] { name }, type, ProblemReasons.Ambiguous); + resolved.setResolvedImport(new ProblemReferenceBinding(new char[][] { name }, type, ProblemReasons.Ambiguous)); return -1; } } @@ -1145,12 +1160,14 @@ private int checkAndRecordImportBinding( for (int j = 0; j < this.importPtr; j++) { ImportBinding resolved = this.tempImports[j]; // find other static fields with the same name - if (resolved.isStatic() && resolved.resolvedImport instanceof FieldBinding && importBinding != resolved.resolvedImport) { + Binding resolvedImport = resolved.getResolvedImport(); + if (resolved.isStatic() + && resolvedImport instanceof FieldBinding field + && importBinding != resolvedImport) { if (CharOperation.equals(name, resolved.compoundName[resolved.compoundName.length - 1])) { if (compilerOptions().sourceLevel >= ClassFileConstants.JDK1_8) { // 7.5.3 says nothing about collision of single static imports and JDK8 tolerates them, though use is flagged. - FieldBinding field = (FieldBinding) resolved.resolvedImport; - resolved.resolvedImport = new ProblemFieldBinding(field, field.declaringClass, name, ProblemReasons.Ambiguous); + resolved.setResolvedImport(new ProblemFieldBinding(field, field.declaringClass, name, ProblemReasons.Ambiguous)); return -1; } else { problemReporter().duplicateImport(importReference); diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ImportBinding.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ImportBinding.java index c51c02a4a29..0e4396d8ac3 100644 --- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ImportBinding.java +++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ImportBinding.java @@ -21,7 +21,7 @@ public class ImportBinding extends Binding { public boolean onDemand; public ImportReference reference; - public Binding resolvedImport; // must ensure the import is resolved + private Binding resolvedImport; public ImportBinding(char[][] compoundName, boolean isOnDemand, Binding binding, ImportReference reference) { this.compoundName = compoundName; @@ -54,6 +54,20 @@ public char[] readableName() { else return CharOperation.concatWith(this.compoundName, '.'); } +public int getResolvedBindingKind() { + if (this.resolvedImport == null) + return 0; + return this.resolvedImport.kind() & (Binding.TYPE | Binding.FIELD | Binding.METHOD); +} +public Binding getResolvedImport() { + return this.resolvedImport; +} + +public Binding setResolvedImport(Binding resolvedImport) { + this.resolvedImport = resolvedImport; + return resolvedImport; +} + @Override public String toString() { return "import : " + new String(readableName()); //$NON-NLS-1$ diff --git a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/Scope.java b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/Scope.java index 4692f7cd11f..3cecc776fd8 100644 --- a/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/Scope.java +++ b/org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/Scope.java @@ -2233,8 +2233,10 @@ public Binding getBinding(char[] name, int mask, InvocationSite invocationSite, for (ImportBinding importBinding : imports) { if (importBinding.isStatic() && !importBinding.onDemand) { if (CharOperation.equals(importBinding.getSimpleName(), name)) { - if (unitScope.resolveSingleImport(importBinding, Binding.TYPE | Binding.FIELD | Binding.METHOD) != null && importBinding.resolvedImport instanceof FieldBinding) { - foundField = (FieldBinding) importBinding.resolvedImport; + if (unitScope.resolveSingleImport(importBinding, Binding.TYPE | Binding.FIELD | Binding.METHOD) != null + && importBinding.getResolvedImport() instanceof FieldBinding resolvedField) + { + foundField = resolvedField; ImportReference importReference = importBinding.reference; if (importReference != null && needResolve) { importReference.bits |= ASTNode.Used; @@ -2259,7 +2261,7 @@ public Binding getBinding(char[] name, int mask, InvocationSite invocationSite, ReferenceBinding sourceCodeReceiver = null; for (ImportBinding importBinding : imports) { if (importBinding.isStatic() && importBinding.onDemand) { - Binding resolvedImport = importBinding.resolvedImport; + Binding resolvedImport = importBinding.getResolvedImport(); if (resolvedImport instanceof ReferenceBinding) { ReferenceBinding importedReferenceBinding = (ReferenceBinding) resolvedImport; FieldBinding temp = findField(importedReferenceBinding, name, invocationSite, needResolve); @@ -2745,7 +2747,7 @@ public MethodBinding getImplicitMethod(char[] selector, TypeBinding[] argumentTy boolean skipOnDemand = false; // set to true when matched static import of method name so stop looking for on demand methods for (ImportBinding importBinding : imports) { if (importBinding.isStatic()) { - Binding resolvedImport = importBinding.resolvedImport; + Binding resolvedImport = importBinding.getResolvedImport(); MethodBinding possible = null; if (importBinding.onDemand) { if (!skipOnDemand && resolvedImport instanceof ReferenceBinding) { @@ -3519,13 +3521,14 @@ final Binding getTypeOrPackage(char[] name, int mask, boolean needResolve) { if (cachedBinding instanceof ImportBinding) { // single type import cached in faultInImports(), replace it in the cache with the type ImportBinding importBinding = (ImportBinding) cachedBinding; ImportReference importReference = importBinding.reference; - if (importReference != null && !isUnnecessarySamePackageImport(importBinding.resolvedImport, unitScope)) { + Binding resolvedImport = importBinding.getResolvedImport(); + if (importReference != null && !isUnnecessarySamePackageImport(resolvedImport, unitScope)) { importReference.bits |= ASTNode.Used; } if (cachedBinding instanceof ImportConflictBinding) typeOrPackageCache.put(name, cachedBinding = ((ImportConflictBinding) cachedBinding).conflictingTypeBinding); // already know its visible else - typeOrPackageCache.put(name, cachedBinding = importBinding.resolvedImport); // already know its visible + typeOrPackageCache.put(name, cachedBinding = resolvedImport); // already know its visible } if ((mask & Binding.TYPE) != 0) { if (foundType != null && foundType.problemId() != ProblemReasons.NotVisible && cachedBinding.problemId() != ProblemReasons.Ambiguous) @@ -3549,7 +3552,7 @@ final Binding getTypeOrPackage(char[] name, int mask, boolean needResolve) { if (resolvedImport == null) continue nextImport; if (resolvedImport instanceof TypeBinding) { ImportReference importReference = importBinding.reference; - if (importReference != null && !isUnnecessarySamePackageImport(importBinding.resolvedImport, unitScope)) + if (importReference != null && !isUnnecessarySamePackageImport(importBinding.getResolvedImport(), unitScope)) importReference.bits |= ASTNode.Used; return resolvedImport; // already know its visible } @@ -3581,7 +3584,7 @@ final Binding getTypeOrPackage(char[] name, int mask, boolean needResolve) { ReferenceBinding type = null; for (ImportBinding someImport : imports) { if (someImport.onDemand) { - Binding resolvedImport = someImport.resolvedImport; + Binding resolvedImport = someImport.getResolvedImport(); ReferenceBinding temp = null; if (resolvedImport instanceof PackageBinding) { temp = findType(name, (PackageBinding) resolvedImport, currentPackage); diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTests21.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTests21.java index e869b45c6f5..f019c093ed9 100644 --- a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTests21.java +++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullAnnotationTests21.java @@ -19,6 +19,7 @@ import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.tests.util.Util; +import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; import junit.framework.Test; @@ -999,6 +1000,8 @@ public class X { } public void testGH1964_since_22() { + if (this.complianceLevel < ClassFileConstants.JDK22) + return; Runner runner = new Runner(); runner.customOptions = getCompilerOptions(); runner.customOptions.put(CompilerOptions.OPTION_EnablePreviews, CompilerOptions.ENABLED); diff --git a/org.eclipse.jdt.core.tests.model/JCL/JclMin21.jar b/org.eclipse.jdt.core.tests.model/JCL/JclMin21.jar deleted file mode 100644 index 08c5e4ae6ee..00000000000 Binary files a/org.eclipse.jdt.core.tests.model/JCL/JclMin21.jar and /dev/null differ diff --git a/org.eclipse.jdt.core.tests.model/JCL/JclMin21src.zip b/org.eclipse.jdt.core.tests.model/JCL/JclMin21src.zip deleted file mode 100644 index 6a770df8493..00000000000 Binary files a/org.eclipse.jdt.core.tests.model/JCL/JclMin21src.zip and /dev/null differ diff --git a/org.eclipse.jdt.core.tests.model/JCL/jclMin21.jar b/org.eclipse.jdt.core.tests.model/JCL/jclMin21.jar new file mode 100644 index 00000000000..d46af004da5 Binary files /dev/null and b/org.eclipse.jdt.core.tests.model/JCL/jclMin21.jar differ diff --git a/org.eclipse.jdt.core.tests.model/JCL/jclMin21src.zip b/org.eclipse.jdt.core.tests.model/JCL/jclMin21src.zip new file mode 100644 index 00000000000..b25aef7c01b Binary files /dev/null and b/org.eclipse.jdt.core.tests.model/JCL/jclMin21src.zip differ diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java index 649c9328376..0d861683ef0 100644 --- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java +++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java @@ -3713,18 +3713,18 @@ public void setUpJCLClasspathVariables(String compliance, boolean useFullJCL) th } } else if ("21".equals(compliance)) { if (JavaCore.getClasspathVariable("JCL_21_LIB") == null) { - setupExternalJCL("jclMin17"); + setupExternalJCL("jclMin21"); JavaCore.setClasspathVariables( - new String[] {"JCL_17_LIB", "JCL_17_SRC", "JCL_SRCROOT"}, - new IPath[] {getExternalJCLPath("17"), getExternalJCLSourcePath("17"), getExternalJCLRootSourcePath()}, + new String[] {"JCL_21_LIB", "JCL_21_SRC", "JCL_SRCROOT"}, + new IPath[] {getExternalJCLPath("21"), getExternalJCLSourcePath("21"), getExternalJCLRootSourcePath()}, null); } } else if ("22".equals(compliance)) { if (JavaCore.getClasspathVariable("JCL_22_LIB") == null) { - setupExternalJCL("jclMin17"); + setupExternalJCL("jclMin21"); JavaCore.setClasspathVariables( - new String[] {"JCL_17_LIB", "JCL_17_SRC", "JCL_SRCROOT"}, - new IPath[] {getExternalJCLPath("17"), getExternalJCLSourcePath("17"), getExternalJCLRootSourcePath()}, + new String[] {"JCL_21_LIB", "JCL_21_SRC", "JCL_SRCROOT"}, + new IPath[] {getExternalJCLPath("21"), getExternalJCLSourcePath("21"), getExternalJCLRootSourcePath()}, null); } } else { diff --git a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/ExternalAnnotations18Test.java b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/ExternalAnnotations18Test.java index 2ff69c3ca72..27dead1db34 100644 --- a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/ExternalAnnotations18Test.java +++ b/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/ExternalAnnotations18Test.java @@ -269,7 +269,10 @@ void setupJavaProject(String name, boolean useFullJCL, boolean addAnnotationLib) } void myCreateJavaProject(String name) throws CoreException { - this.project = createJavaProject(name, new String[]{"src"}, new String[]{this.jclLib}, null, null, "bin", null, null, null, this.compliance); + myCreateJavaProject(name, this.compliance, this.jclLib); + } + void myCreateJavaProject(String name, String projectCompliance, String projectJclLib) throws CoreException { + this.project = createJavaProject(name, new String[]{"src"}, new String[]{projectJclLib}, null, null, "bin", null, null, null, projectCompliance); addLibraryEntry(this.project, this.ANNOTATION_LIB, false); Map options = this.project.getOptions(true); options.put(JavaCore.COMPILER_ANNOTATION_NULL_ANALYSIS, JavaCore.ENABLED); @@ -3353,4 +3356,76 @@ Integer test() { IProblem[] problems = reconciled.getProblems(); assertNoProblems(problems); } + public void testGH2178() throws CoreException, IOException { + myCreateJavaProject("GH2178", "21", "JCL_21_LIB"); + Map options = this.project.getOptions(true); + options.put(JavaCore.COMPILER_PB_NULL_SPECIFICATION_VIOLATION, JavaCore.ERROR); + options.put(JavaCore.COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT, JavaCore.ERROR); + this.project.setOptions(options); + + addLibraryWithExternalAnnotations(this.project, "21", "jreext.jar", "annots", new String[] { + "/UnannotatedLib/lib/Objects.java", + """ + package lib; + public class Objects { + public static T requireNonNull(T t) { return t; } + } + """ + }, null); + createFileInProject("annots/java/lang", "String.eea", + """ + class java/lang/String + valueOf + (Z)Ljava/lang/String; + (Z)L1java/lang/String; + """); + createFileInProject("annots/lib", "Objects.eea", + """ + class lib/Objects + requireNonNull + (TT;)TT; + (T0T;)T1T; + """); + addEeaToVariableEntry("JCL_21_LIB", "/GH2178/annots"); + + + IPackageFragment fragment = this.project.getPackageFragmentRoots()[0].createPackageFragment("repro", true, null); + ICompilationUnit unit = fragment.createCompilationUnit("ExternalNullAnnotationsConfusion.java", + """ + package repro; + + import lib.Objects; + + import org.eclipse.jdt.annotation.NonNull; + + public class ExternalNullAnnotationsConfusion { + + public String conflictingNonNullAndNullable() { + + // String.valueOf() is annotated to return @NonNull + @NonNull + String valueOfAnnotatedNonNull = String.valueOf(false); + + // Objects.requireNonNull is annotated to take a @Nullable parameter + @NonNull + String result = Objects.requireNonNull(valueOfAnnotatedNonNull); + + // error marker at the last argument in the previous line: + // Contradictory null annotations: + // method was inferred as '@NonNull String requireNonNull(@Nullable @NonNull String)', + // but only one of '@NonNull' and '@Nullable' can be effective at any location + return result; + } + } + """, + true, new NullProgressMonitor()).getWorkingCopy(new NullProgressMonitor()); + CompilationUnit reconciled = unit.reconcile(getJLS8(), true, null, new NullProgressMonitor()); + IProblem[] problems = reconciled.getProblems(); + assertNoProblems(problems); + + this.project.getProject().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, null); + IMarker[] markers = this.project.getProject().findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, false, IResource.DEPTH_INFINITE); + assertNoMarkers(markers); + } + } 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 index a3f613bee9e..e322e384a1c 100644 --- 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 @@ -8099,9 +8099,9 @@ private void findFieldsAndMethodsFromFavorites( if (favoriteBindings != null && favoriteBindings.length > 0) { for (ImportBinding favoriteBinding : favoriteBindings) { - switch (favoriteBinding.resolvedImport.kind()) { + switch (favoriteBinding.getResolvedBindingKind()) { case Binding.FIELD: - FieldBinding fieldBinding = (FieldBinding) favoriteBinding.resolvedImport; + FieldBinding fieldBinding = (FieldBinding) favoriteBinding.getResolvedImport(); findFieldsFromFavorites( token, new FieldBinding[]{fieldBinding}, @@ -8113,7 +8113,7 @@ private void findFieldsAndMethodsFromFavorites( invocationScope); break; case Binding.METHOD: - MethodBinding methodBinding = (MethodBinding) favoriteBinding.resolvedImport; + MethodBinding methodBinding = (MethodBinding) favoriteBinding.getResolvedImport(); MethodBinding[] methods = methodBinding.declaringClass.availableMethods(); long range; if ((range = ReferenceBinding.binarySearch(methodBinding.selector, methods)) >= 0) { @@ -8134,7 +8134,7 @@ private void findFieldsAndMethodsFromFavorites( invocationScope); break; case Binding.TYPE: - ReferenceBinding referenceBinding = (ReferenceBinding) favoriteBinding.resolvedImport; + ReferenceBinding referenceBinding = (ReferenceBinding) favoriteBinding.getResolvedImport(); if(favoriteBinding.onDemand) { findFieldsFromFavorites( token, @@ -8342,7 +8342,7 @@ private void findFieldsAndMethodsFromStaticImports( ImportBinding[] importBindings = scope.compilationUnitScope().imports; for (ImportBinding importBinding : importBindings) { if(importBinding.isValidBinding() && importBinding.isStatic()) { - Binding binding = importBinding.resolvedImport; + Binding binding = importBinding.getResolvedImport(); if(binding != null && binding.isValidBinding()) { if(importBinding.onDemand) { if((binding.kind() & Binding.TYPE) != 0) { @@ -12462,7 +12462,7 @@ private void findTypesFromImports(char[] token, Scope scope, boolean proposeType ImportBinding[] importBindings = scope.compilationUnitScope().imports; next : for (ImportBinding importBinding : importBindings) { if(importBinding.isValidBinding()) { - Binding binding = importBinding.resolvedImport; + Binding binding = importBinding.getResolvedImport(); if(binding != null && binding.isValidBinding()) { if(importBinding.onDemand) { if (importBinding.isStatic()) { @@ -12588,7 +12588,7 @@ private void findTypesFromStaticImports(char[] token, Scope scope, boolean propo if (importBindings == null) return; for (ImportBinding importBinding : importBindings) { if(importBinding.isValidBinding() && importBinding.isStatic()) { - Binding binding = importBinding.resolvedImport; + Binding binding = importBinding.getResolvedImport(); if(binding != null && binding.isValidBinding()) { if(importBinding.onDemand) { if((binding.kind() & Binding.TYPE) != 0) { 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 index 1752a27ae3c..62a864eb697 100644 --- 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 @@ -852,7 +852,7 @@ private void searchVisibleVariablesAndMethods( ImportBinding[] importBindings = scope.compilationUnitScope().imports; for (ImportBinding importBinding : importBindings) { if(importBinding.isValidBinding() && importBinding.isStatic()) { - Binding binding = importBinding.resolvedImport; + Binding binding = importBinding.getResolvedImport(); if(binding != null && binding.isValidBinding()) { if(importBinding.onDemand) { if((binding.kind() & Binding.TYPE) != 0) { diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/Engine.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/Engine.java index ac76fd8df38..295c2fa3ce5 100644 --- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/Engine.java +++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/impl/Engine.java @@ -164,7 +164,7 @@ public void initializeImportCaches() { this.onDemandImportsCache[this.onDemandImportCacheCount++] = importBinding; } else { - if(!(importBinding.resolvedImport instanceof MethodBinding) || + if(!(importBinding.getResolvedImport() instanceof MethodBinding) || importBinding instanceof ImportConflictBinding) { if(this.importsCache == null) { this.importsCache = new char[length - i][][]; @@ -232,7 +232,7 @@ protected boolean mustQualifyType( for (int i = 0; i < this.onDemandImportCacheCount; i++) { ImportBinding importBinding = this.onDemandImportsCache[i]; - Binding resolvedImport = importBinding.resolvedImport; + Binding resolvedImport = importBinding.getResolvedImport(); char[][] importName = importBinding.compoundName; char[] importFlatName = CharOperation.concatWith(importName, '.'); @@ -273,9 +273,7 @@ protected boolean mustQualifyType( for (int j = 0; j < this.onDemandImportCacheCount; j++) { if(i != j) { ImportBinding conflictingImportBinding = this.onDemandImportsCache[j]; - if(conflictingImportBinding.resolvedImport instanceof ReferenceBinding) { - ReferenceBinding refBinding = - (ReferenceBinding) conflictingImportBinding.resolvedImport; + if(conflictingImportBinding.getResolvedImport() instanceof ReferenceBinding refBinding) { if (refBinding.getMemberType(typeName) != null) { return true; }