package org.eclipse.jdt.internal.compiler.lookup;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ClassFilePool;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.*;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.ITypeRequestor;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.util.HashtableOfModule;
import org.eclipse.jdt.internal.compiler.util.HashtableOfPackage;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
@SuppressWarnings({"rawtypes", "unchecked"})
public class LookupEnvironment implements ProblemReasons, TypeConstants {
private Map accessRestrictions;
ImportBinding[] defaultImports;
public final LookupEnvironment root;
public ModuleBinding UnNamedModule;
public ModuleBinding JavaBaseModule;
public ModuleBinding module;
public PlainPackageBinding defaultPackage;
HashtableOfPackage knownPackages;
private int lastCompletedUnitIndex = -1;
private int lastUnitIndex = -1;
TypeSystem typeSystem;
public INameEnvironment nameEnvironment;
public CompilerOptions globalOptions;
public ProblemReporter problemReporter;
public ClassFilePool classFilePool;
private int stepCompleted;
public ITypeRequestor typeRequestor;
private SimpleLookupTable uniqueParameterizedGenericMethodBindings;
private SimpleLookupTable uniquePolymorphicMethodBindings;
private SimpleLookupTable uniqueGetClassMethodBinding;
boolean useModuleSystem;
public HashtableOfModule knownModules;
public CompilationUnitDeclaration unitBeingCompleted = null;
public Object missingClassFileLocation = null;
private CompilationUnitDeclaration[] units = new CompilationUnitDeclaration[4];
private MethodVerifier verifier;
private ArrayList missingTypes;
Set<SourceTypeBinding> typesBeingConnected;
public boolean isProcessingAnnotations = false;
public boolean mayTolerateMissingType = false;
PackageBinding nullableAnnotationPackage;
PackageBinding nonnullAnnotationPackage;
PackageBinding nonnullByDefaultAnnotationPackage;
AnnotationBinding nonNullAnnotation;
AnnotationBinding nullableAnnotation;
Map<String,Integer> allNullAnnotations = null;
final List<MethodBinding> deferredEnumMethods;
InferenceContext18 currentInferenceContext;
public boolean suppressImportErrors;
public String moduleVersion;
final static int BUILD_FIELDS_AND_METHODS = 4;
final static int BUILD_TYPE_HIERARCHY = 1;
final static int CHECK_AND_SET_IMPORTS = 2;
final static int CONNECT_TYPE_HIERARCHY = 3;
static final ProblemPackageBinding TheNotFoundPackage = new ProblemPackageBinding(CharOperation.NO_CHAR, NotFound, null);
static final ProblemReferenceBinding TheNotFoundType = new ProblemReferenceBinding(CharOperation.NO_CHAR_CHAR, null, NotFound);
static final ModuleBinding TheNotFoundModule = new ModuleBinding(CharOperation.NO_CHAR);
public LookupEnvironment(ITypeRequestor typeRequestor, CompilerOptions globalOptions, ProblemReporter problemReporter, INameEnvironment nameEnvironment) {
this.root = this;
this.UnNamedModule = new ModuleBinding.UnNamedModule(this);
this.module = this.UnNamedModule;
this.typeRequestor = typeRequestor;
this.globalOptions = globalOptions;
this.problemReporter = problemReporter;
this.defaultPackage = new PlainPackageBinding(this);
this.defaultImports = null;
this.nameEnvironment = nameEnvironment;
this.knownPackages = new HashtableOfPackage();
this.uniqueParameterizedGenericMethodBindings = new SimpleLookupTable(3);
this.uniquePolymorphicMethodBindings = new SimpleLookupTable(3);
this.missingTypes = null;
this.accessRestrictions = new HashMap(3);
this.classFilePool = ClassFilePool.newInstance();
this.typesBeingConnected = new HashSet<>();
this.deferredEnumMethods = new ArrayList<>();
this.typeSystem = this.globalOptions.sourceLevel >= ClassFileConstants.JDK1_8 && this.globalOptions.storeAnnotations ? new AnnotatableTypeSystem(this) : new TypeSystem(this);
this.knownModules = new HashtableOfModule();
this.useModuleSystem = nameEnvironment instanceof IModuleAwareNameEnvironment && globalOptions.complianceLevel >= ClassFileConstants.JDK9;
this.resolutionListeners = new IQualifiedTypeResolutionListener[0];
}
LookupEnvironment(LookupEnvironment rootEnv, ModuleBinding module) {
this.root = rootEnv;
this.UnNamedModule = rootEnv.UnNamedModule;
this.module = module;
this.typeRequestor = rootEnv.typeRequestor;
this.globalOptions = rootEnv.globalOptions;
this.problemReporter = rootEnv.problemReporter;
this.defaultPackage = new PlainPackageBinding(this);
this.defaultImports = null;
this.nameEnvironment = rootEnv.nameEnvironment;
this.knownPackages = new HashtableOfPackage();
this.uniqueParameterizedGenericMethodBindings = new SimpleLookupTable(3);
this.uniquePolymorphicMethodBindings = new SimpleLookupTable(3);
this.missingTypes = null;
this.accessRestrictions = new HashMap(3);
this.classFilePool = rootEnv.classFilePool;
this.typesBeingConnected = rootEnv.typesBeingConnected;
this.deferredEnumMethods = rootEnv.deferredEnumMethods;
this.typeSystem = rootEnv.typeSystem;
this.useModuleSystem = rootEnv.useModuleSystem;
}
public ModuleBinding getModule(char[] name) {
if (this.root != this)
return this.root.getModule(name);
if (name == null || name == ModuleBinding.UNNAMED || CharOperation.equals(name, ModuleBinding.ALL_UNNAMED))
return this.UnNamedModule;
ModuleBinding moduleBinding = this.knownModules.get(name);
if (moduleBinding == null) {
if (this.useModuleSystem) {
IModule mod = ((IModuleAwareNameEnvironment) this.nameEnvironment).getModule(name);
if (mod != null) {
this.typeRequestor.accept(mod, this);
moduleBinding = this.root.knownModules.get(name);
}
} else
return this.UnNamedModule;
}
return moduleBinding;
}
public ReferenceBinding askForType(char[][] compoundName, ModuleBinding clientModule) {
assert clientModule != null : "lookup needs a module";
NameEnvironmentAnswer[] answers = null;
if (this.useModuleSystem) {
IModuleAwareNameEnvironment moduleEnv = (IModuleAwareNameEnvironment) this.nameEnvironment;
answers = askForTypeFromModules(clientModule, clientModule.getAllRequiredModules(),
mod -> moduleEnv.findType(compoundName, mod.nameForLookup()));
} else {
NameEnvironmentAnswer answer = this.nameEnvironment.findType(compoundName);
if (answer != null) {
answer.moduleBinding = this.module;
answers = new NameEnvironmentAnswer[] { answer };
}
}
if (answers == null)
return null;
ReferenceBinding candidate = null;
for (NameEnvironmentAnswer answer : answers) {
if (answer == null) continue;
ModuleBinding answerModule = answer.moduleBinding != null ? answer.moduleBinding : this.UnNamedModule;
if (answer.isBinaryType()) {
PackageBinding pkg = answerModule.environment.computePackageFrom(compoundName, false );
this.typeRequestor.accept(answer.getBinaryType(), pkg, answer.getAccessRestriction());
ReferenceBinding binding = pkg.getType0(compoundName[compoundName.length - 1]);
if (binding instanceof BinaryTypeBinding) {
((BinaryTypeBinding) binding).module = answerModule;
if (pkg.enclosingModule == null)
pkg.enclosingModule = answerModule;
}
} else if (answer.isCompilationUnit()) {
this.typeRequestor.accept(answer.getCompilationUnit(), answer.getAccessRestriction());
} else if (answer.isSourceType()) {
PackageBinding pkg = answerModule.environment.computePackageFrom(compoundName, false );
this.typeRequestor.accept(answer.getSourceTypes(), pkg, answer.getAccessRestriction());
ReferenceBinding binding = pkg.getType0(compoundName[compoundName.length - 1]);
if (binding instanceof SourceTypeBinding) {
((SourceTypeBinding) binding).module = answerModule;
if (pkg.enclosingModule == null)
pkg.enclosingModule = answerModule;
}
}
candidate = combine(candidate, answerModule.environment.getCachedType(compoundName), clientModule);
}
return candidate;
}
ReferenceBinding askForType(PackageBinding packageBinding, char[] name, ModuleBinding clientModule) {
assert clientModule != null : "lookup needs a module";
if (packageBinding == null) {
packageBinding = this.defaultPackage;
}
NameEnvironmentAnswer[] answers = null;
if (this.useModuleSystem) {
IModuleAwareNameEnvironment moduleEnv = (IModuleAwareNameEnvironment) this.nameEnvironment;
final PackageBinding pack = packageBinding;
answers = askForTypeFromModules(null, packageBinding.getDeclaringModules(),
mod -> fromSplitPackageOrOracle(moduleEnv, mod, pack, name));
} else {
NameEnvironmentAnswer answer = this.nameEnvironment.findType(name, packageBinding.compoundName);
if (answer != null) {
answer.moduleBinding = this.module;
answers = new NameEnvironmentAnswer[] { answer };
}
}
if (answers == null)
return null;
ReferenceBinding candidate = null;
for (NameEnvironmentAnswer answer : answers) {
if (answer == null) continue;
if (candidate != null && candidate.problemId() == ProblemReasons.Ambiguous)
return candidate;
ModuleBinding answerModule = answer.moduleBinding != null ? answer.moduleBinding : this.UnNamedModule;
PackageBinding answerPackage = packageBinding;
if (answerModule != null) {
if (!answerPackage.isDeclaredIn(answerModule))
continue;
answerPackage = answerPackage.getIncarnation(answerModule);
}
if (answer.isResolvedBinding()) {
candidate = combine(candidate, answer.getResolvedBinding(), clientModule);
continue;
} else if (answer.isBinaryType()) {
this.typeRequestor.accept(answer.getBinaryType(), answerPackage, answer.getAccessRestriction());
ReferenceBinding binding = answerPackage.getType0(name);
if (binding instanceof BinaryTypeBinding) {
((BinaryTypeBinding) binding).module = answerModule;
}
} else if (answer.isCompilationUnit()) {
try {
this.typeRequestor.accept(answer.getCompilationUnit(), answer.getAccessRestriction());
} catch (AbortCompilation abort) {
if (CharOperation.equals(name, TypeConstants.PACKAGE_INFO_NAME))
return null;
throw abort;
}
} else if (answer.isSourceType()) {
this.typeRequestor.accept(answer.getSourceTypes(), answerPackage, answer.getAccessRestriction());
ReferenceBinding binding = answerPackage.getType0(name);
if (binding instanceof SourceTypeBinding) {
((SourceTypeBinding) binding).module = answerModule;
}
String externalAnnotationPath = answer.getExternalAnnotationPath();
if (externalAnnotationPath != null && this.globalOptions.isAnnotationBasedNullAnalysisEnabled && binding instanceof SourceTypeBinding) {
ExternalAnnotationSuperimposer.apply((SourceTypeBinding) binding, externalAnnotationPath);
}
candidate = combine(candidate, binding, clientModule);
continue;
}
candidate = combine(candidate, answerPackage.getType0(name), clientModule);
}
return candidate;
}
private ReferenceBinding combine(ReferenceBinding one, ReferenceBinding two, ModuleBinding clientModule) {
if (one == null) return two;
if (two == null) return one;
if (one.fPackage == null || !clientModule.canAccess(one.fPackage)) return two;
if (two.fPackage == null || !clientModule.canAccess(two.fPackage)) return one;
if (one == two) return one;
return new ProblemReferenceBinding(one.compoundName, one, ProblemReasons.Ambiguous);
}
private NameEnvironmentAnswer[] askForTypeFromModules(ModuleBinding clientModule, ModuleBinding[] otherModules,
Function<ModuleBinding,NameEnvironmentAnswer> oracle)
{
if (clientModule != null && clientModule.nameForLookup().length == 0) {
NameEnvironmentAnswer answer = oracle.apply(clientModule);
if (answer != null)
answer.moduleBinding = this.root.getModuleFromAnswer(answer);
return new NameEnvironmentAnswer[] { answer };
} else {
boolean found = false;
NameEnvironmentAnswer[] answers = null;
if (clientModule != null) {
answers = new NameEnvironmentAnswer[otherModules.length+1];
NameEnvironmentAnswer answer = oracle.apply(clientModule);
if (answer != null) {
answer.moduleBinding = clientModule;
answers[answers.length-1] = answer;
found = true;
}
} else {
answers = new NameEnvironmentAnswer[otherModules.length];
}
for (int i = 0; i < otherModules.length; i++) {
NameEnvironmentAnswer answer = oracle.apply(otherModules[i]);
if (answer != null) {
if (answer.moduleBinding == null) {
char[] nameFromAnswer = answer.moduleName();
if (CharOperation.equals(nameFromAnswer, otherModules[i].moduleName)) {
answer.moduleBinding = otherModules[i];
} else {
answer.moduleBinding = getModule(nameFromAnswer);
}
}
answers[i] = answer;
found = true;
}
}
return found ? answers : null;
}
}
private static NameEnvironmentAnswer fromSplitPackageOrOracle(IModuleAwareNameEnvironment moduleEnv, ModuleBinding module,
PackageBinding packageBinding, char[] name)
{
if (packageBinding instanceof SplitPackageBinding) {
ReferenceBinding binding = ((SplitPackageBinding) packageBinding).getType0ForModule(module, name);
if (binding != null && binding.isValidBinding()) {
if (binding instanceof UnresolvedReferenceBinding)
binding = ((UnresolvedReferenceBinding) binding).resolve(module.environment, false);
if (binding.isValidBinding())
return new NameEnvironmentAnswer(binding, module);
}
}
return moduleEnv.findType(name, packageBinding.compoundName, module.nameForLookup());
}
private ModuleBinding getModuleFromAnswer(NameEnvironmentAnswer answer) {
char[] moduleName = answer.moduleName();
if (moduleName != null) {
ModuleBinding moduleBinding;
if (!this.useModuleSystem || moduleName == ModuleBinding.UNNAMED) {
moduleBinding = this.UnNamedModule;
} else {
moduleBinding = this.knownModules.get(moduleName);
if (moduleBinding == null && this.nameEnvironment instanceof IModuleAwareNameEnvironment) {
IModule iModule = ((IModuleAwareNameEnvironment) this.nameEnvironment).getModule(moduleName);
try {
this.typeRequestor.accept(iModule, this);
moduleBinding = this.knownModules.get(moduleName);
} catch (NullPointerException e) {
System.err.println("Bug 529367: moduleName: " + new String(moduleName) + "iModule null" +
(iModule == null ? "true" : "false"));
throw e;
}
}
}
return moduleBinding;
}
return null;
}
public boolean canTypeBeAccessed(SourceTypeBinding binding, Scope scope) {
ModuleBinding client = scope.module();
return client.canAccess(binding.fPackage);
}
public void buildTypeBindings(CompilationUnitDeclaration unit, AccessRestriction accessRestriction) {
CompilationUnitScope scope;
ModuleBinding unitModule = null;
if (unit.moduleDeclaration != null) {
char[] moduleName = unit.moduleDeclaration.moduleName;
scope = new CompilationUnitScope(unit, this.globalOptions);
unitModule = unit.moduleDeclaration.setBinding(new SourceModuleBinding(moduleName, scope, this.root));
} else {
unitModule = unit.module(this);
scope = new CompilationUnitScope(unit, unitModule != null ? unitModule.environment : this);
}
scope.buildTypeBindings(accessRestriction);
LookupEnvironment rootEnv = this.root;
int unitsLength = rootEnv.units.length;
if (++rootEnv.lastUnitIndex >= unitsLength)
System.arraycopy(rootEnv.units, 0, rootEnv.units = new CompilationUnitDeclaration[2 * unitsLength], 0, unitsLength);
rootEnv.units[rootEnv.lastUnitIndex] = unit;
}
public BinaryTypeBinding cacheBinaryType(IBinaryType binaryType, AccessRestriction accessRestriction) {
return cacheBinaryType(binaryType, true, accessRestriction);
}
public BinaryTypeBinding cacheBinaryType(IBinaryType binaryType, boolean needFieldsAndMethods, AccessRestriction accessRestriction) {
char[][] compoundName = CharOperation.splitOn('/', binaryType.getName());
ReferenceBinding existingType = getCachedType(compoundName);
if (existingType == null || existingType instanceof UnresolvedReferenceBinding)
return createBinaryTypeFrom(binaryType, computePackageFrom(compoundName, false ), needFieldsAndMethods, accessRestriction);
return null;
}
public void completeTypeBindings() {
if (this != this.root) {
this.root.completeTypeBindings();
return;
}
this.stepCompleted = BUILD_TYPE_HIERARCHY;
for (int i = this.lastCompletedUnitIndex + 1; i <= this.lastUnitIndex; i++) {
(this.unitBeingCompleted = this.units[i]).scope.checkAndSetImports();
}
this.stepCompleted = CHECK_AND_SET_IMPORTS;
for (int i = this.lastCompletedUnitIndex + 1; i <= this.lastUnitIndex; i++) {
(this.unitBeingCompleted = this.units[i]).scope.connectTypeHierarchy();
}
this.stepCompleted = CONNECT_TYPE_HIERARCHY;
for (int i = this.lastCompletedUnitIndex + 1; i <= this.lastUnitIndex; i++) {
CompilationUnitScope unitScope = (this.unitBeingCompleted = this.units[i]).scope;
unitScope.checkParameterizedTypes();
unitScope.buildFieldsAndMethods();
this.units[i] = null;
}
this.stepCompleted = BUILD_FIELDS_AND_METHODS;
this.lastCompletedUnitIndex = this.lastUnitIndex;
this.unitBeingCompleted = null;
}
public void completeTypeBindings(CompilationUnitDeclaration parsedUnit) {
if (this != this.root) {
this.root.completeTypeBindings(parsedUnit);
return;
}
if (this.stepCompleted == BUILD_FIELDS_AND_METHODS) {
completeTypeBindings();
} else {
if (parsedUnit.scope == null) return;
if (this.stepCompleted >= CHECK_AND_SET_IMPORTS)
(this.unitBeingCompleted = parsedUnit).scope.checkAndSetImports();
if (this.stepCompleted >= CONNECT_TYPE_HIERARCHY)
(this.unitBeingCompleted = parsedUnit).scope.connectTypeHierarchy();
this.unitBeingCompleted = null;
}
}
public void completeTypeBindings(CompilationUnitDeclaration parsedUnit, boolean buildFieldsAndMethods) {
if (parsedUnit.scope == null) return;
LookupEnvironment rootEnv = this.root;
CompilationUnitDeclaration previousUnitBeingCompleted = rootEnv.unitBeingCompleted;
(rootEnv.unitBeingCompleted = parsedUnit).scope.checkAndSetImports();
parsedUnit.scope.connectTypeHierarchy();
parsedUnit.scope.checkParameterizedTypes();
if (buildFieldsAndMethods)
parsedUnit.scope.buildFieldsAndMethods();
rootEnv.unitBeingCompleted = previousUnitBeingCompleted;
}
public void completeTypeBindings(CompilationUnitDeclaration[] parsedUnits, boolean[] buildFieldsAndMethods, int unitCount) {
LookupEnvironment rootEnv = this.root;
for (int i = 0; i < unitCount; i++) {
CompilationUnitDeclaration parsedUnit = parsedUnits[i];
if (parsedUnit.scope != null)
(rootEnv.unitBeingCompleted = parsedUnit).scope.checkAndSetImports();
}
for (int i = 0; i < unitCount; i++) {
CompilationUnitDeclaration parsedUnit = parsedUnits[i];
if (parsedUnit.scope != null)
(rootEnv.unitBeingCompleted = parsedUnit).scope.connectTypeHierarchy();
}
for (int i = 0; i < unitCount; i++) {
CompilationUnitDeclaration parsedUnit = parsedUnits[i];
if (parsedUnit.scope != null) {
(rootEnv.unitBeingCompleted = parsedUnit).scope.checkParameterizedTypes();
if (buildFieldsAndMethods[i])
parsedUnit.scope.buildFieldsAndMethods();
}
}
rootEnv.unitBeingCompleted = null;
}
public TypeBinding computeBoxingType(TypeBinding type) {
TypeBinding boxedType;
switch (type.id) {
case TypeIds.T_JavaLangBoolean :
return TypeBinding.BOOLEAN;
case TypeIds.T_JavaLangByte :
return TypeBinding.BYTE;
case TypeIds.T_JavaLangCharacter :
return TypeBinding.CHAR;
case TypeIds.T_JavaLangShort :
return TypeBinding.SHORT;
case TypeIds.T_JavaLangDouble :
return TypeBinding.DOUBLE;
case TypeIds.T_JavaLangFloat :
return TypeBinding.FLOAT;
case TypeIds.T_JavaLangInteger :
return TypeBinding.INT;
case TypeIds.T_JavaLangLong :
return TypeBinding.LONG;
case TypeIds.T_int :
boxedType = getType(JAVA_LANG_INTEGER, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_INTEGER, null, NotFound);
case TypeIds.T_byte :
boxedType = getType(JAVA_LANG_BYTE, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_BYTE, null, NotFound);
case TypeIds.T_short :
boxedType = getType(JAVA_LANG_SHORT, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_SHORT, null, NotFound);
case TypeIds.T_char :
boxedType = getType(JAVA_LANG_CHARACTER, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_CHARACTER, null, NotFound);
case TypeIds.T_long :
boxedType = getType(JAVA_LANG_LONG, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_LONG, null, NotFound);
case TypeIds.T_float :
boxedType = getType(JAVA_LANG_FLOAT, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_FLOAT, null, NotFound);
case TypeIds.T_double :
boxedType = getType(JAVA_LANG_DOUBLE, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_DOUBLE, null, NotFound);
case TypeIds.T_boolean :
boxedType = getType(JAVA_LANG_BOOLEAN, javaBaseModule());
if (boxedType != null) return boxedType;
return new ProblemReferenceBinding(JAVA_LANG_BOOLEAN, null, NotFound);
}
switch (type.kind()) {
case Binding.WILDCARD_TYPE :
case Binding.INTERSECTION_TYPE :
case Binding.TYPE_PARAMETER :
case Binding.INTERSECTION_TYPE18:
switch (type.erasure().id) {
case TypeIds.T_JavaLangBoolean :
return TypeBinding.BOOLEAN;
case TypeIds.T_JavaLangByte :
return TypeBinding.BYTE;
case TypeIds.T_JavaLangCharacter :
return TypeBinding.CHAR;
case TypeIds.T_JavaLangShort :
return TypeBinding.SHORT;
case TypeIds.T_JavaLangDouble :
return TypeBinding.DOUBLE;
case TypeIds.T_JavaLangFloat :
return TypeBinding.FLOAT;
case TypeIds.T_JavaLangInteger :
return TypeBinding.INT;
case TypeIds.T_JavaLangLong :
return TypeBinding.LONG;
}
break;
case Binding.POLY_TYPE:
return ((PolyTypeBinding) type).computeBoxingType();
}
return type;
}
public ModuleBinding javaBaseModule() {
if (this.JavaBaseModule != null)
return this.JavaBaseModule;
if (this.root != this)
return this.JavaBaseModule = this.root.javaBaseModule();
ModuleBinding resolvedModel = null;
if (this.useModuleSystem)
resolvedModel = getModule(TypeConstants.JAVA_BASE);
return this.JavaBaseModule = (resolvedModel != null ? resolvedModel : this.UnNamedModule);
}
private PackageBinding computePackageFrom(char[][] constantPoolName, boolean isMissing) {
if (constantPoolName.length == 1)
return this.defaultPackage;
PackageBinding packageBinding = getPackage0(constantPoolName[0]);
if (packageBinding == null || packageBinding == TheNotFoundPackage) {
if (this.useModuleSystem) {
if (this.module.isUnnamed()) {
char[][] declaringModules = ((IModuleAwareNameEnvironment) this.nameEnvironment).getUniqueModulesDeclaringPackage(new char[][] {constantPoolName[0]}, ModuleBinding.ANY);
if (declaringModules != null) {
for (char[] mod : declaringModules) {
ModuleBinding declaringModule = this.root.getModule(mod);
if (declaringModule != null)
packageBinding = SplitPackageBinding.combine(declaringModule.getTopLevelPackage(constantPoolName[0]), packageBinding, this.module);
}
}
} else {
packageBinding = this.module.getTopLevelPackage(constantPoolName[0]);
}
}
if (packageBinding == null || packageBinding == TheNotFoundPackage) {
packageBinding = this.module.createDeclaredToplevelPackage(constantPoolName[0]);
}
if (isMissing) packageBinding.tagBits |= TagBits.HasMissingType;
this.knownPackages.put(constantPoolName[0], packageBinding);
}
for (int i = 1, length = constantPoolName.length - 1; i < length; i++) {
PackageBinding parent = packageBinding;
if ((packageBinding = parent.getPackage0(constantPoolName[i])) == null || packageBinding == TheNotFoundPackage) {
if (this.useModuleSystem) {
if (this.module.isUnnamed()) {
char[][] currentCompoundName = CharOperation.arrayConcat(parent.compoundName, constantPoolName[i]);
char[][] declaringModules = ((IModuleAwareNameEnvironment) this.nameEnvironment).getModulesDeclaringPackage(
currentCompoundName, ModuleBinding.ANY);
if (declaringModules != null) {
for (char[] mod : declaringModules) {
ModuleBinding declaringModule = this.root.getModule(mod);
if (declaringModule != null)
packageBinding = SplitPackageBinding.combine(declaringModule.getVisiblePackage(currentCompoundName), packageBinding, this.module);
}
}
} else {
packageBinding = this.module.getVisiblePackage(parent, constantPoolName[i]);
}
}
if (packageBinding == null || packageBinding == TheNotFoundPackage) {
packageBinding = this.module.createDeclaredPackage(CharOperation.subarray(constantPoolName, 0, i + 1), parent);
}
if (isMissing) {
packageBinding.tagBits |= TagBits.HasMissingType;
}
packageBinding = parent.addPackage(packageBinding, this.module);
}
}
if (packageBinding instanceof SplitPackageBinding) {
PackageBinding candidate = null;
for (PackageBinding incarnation : ((SplitPackageBinding) packageBinding).incarnations) {
if (incarnation.hasCompilationUnit(false)) {
if (candidate != null) {
candidate = null;
break;
}
candidate = incarnation;
}
}
if (candidate != null)
return candidate;
}
return packageBinding;
}
public ReferenceBinding convertToParameterizedType(ReferenceBinding originalType) {
if (originalType != null) {
boolean isGeneric = originalType.isGenericType();
if (!isGeneric && !originalType.hasEnclosingInstanceContext())
return originalType;
ReferenceBinding originalEnclosingType = originalType.enclosingType();
ReferenceBinding convertedEnclosingType = originalEnclosingType;
boolean needToConvert = isGeneric;
if (originalEnclosingType != null && originalType.hasEnclosingInstanceContext()) {
convertedEnclosingType = convertToParameterizedType(originalEnclosingType);
needToConvert |= TypeBinding.notEquals(originalEnclosingType, convertedEnclosingType);
}
if (needToConvert) {
return createParameterizedType(originalType, isGeneric ? originalType.typeVariables() : null, convertedEnclosingType);
}
}
return originalType;
}
public TypeBinding convertToRawType(TypeBinding type, boolean forceRawEnclosingType) {
int dimension;
TypeBinding originalType;
switch(type.kind()) {
case Binding.BASE_TYPE :
case Binding.TYPE_PARAMETER:
case Binding.WILDCARD_TYPE:
case Binding.INTERSECTION_TYPE:
case Binding.RAW_TYPE:
return type;
case Binding.ARRAY_TYPE:
dimension = type.dimensions();
originalType = type.leafComponentType();
break;
default:
if (type.id == TypeIds.T_JavaLangObject)
return type;
dimension = 0;
originalType = type;
}
boolean needToConvert;
switch (originalType.kind()) {
case Binding.BASE_TYPE :
return type;
case Binding.GENERIC_TYPE :
needToConvert = true;
break;
case Binding.PARAMETERIZED_TYPE :
ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) originalType;
needToConvert = paramType.genericType().isGenericType();
break;
default :
needToConvert = false;
break;
}
forceRawEnclosingType &= !originalType.isStatic();
ReferenceBinding originalEnclosing = originalType.enclosingType();
TypeBinding convertedType;
if (originalEnclosing == null) {
convertedType = needToConvert ? createRawType((ReferenceBinding)originalType.erasure(), null) : originalType;
} else {
ReferenceBinding convertedEnclosing;
if (!((ReferenceBinding)originalType).hasEnclosingInstanceContext()) {
convertedEnclosing = (ReferenceBinding) originalEnclosing.original();
} else {
if (originalEnclosing.kind() == Binding.RAW_TYPE) {
convertedEnclosing = originalEnclosing;
needToConvert = true;
} else if (forceRawEnclosingType && !needToConvert) {
convertedEnclosing = (ReferenceBinding) convertToRawType(originalEnclosing, forceRawEnclosingType);
needToConvert = TypeBinding.notEquals(originalEnclosing, convertedEnclosing);
} else if (needToConvert) {
convertedEnclosing = (ReferenceBinding) convertToRawType(originalEnclosing, false);
} else {
convertedEnclosing = convertToParameterizedType(originalEnclosing);
}
}
if (needToConvert) {
convertedType = createRawType((ReferenceBinding) originalType.erasure(), convertedEnclosing);
} else if (TypeBinding.notEquals(originalEnclosing, convertedEnclosing)) {
convertedType = createParameterizedType((ReferenceBinding) originalType.erasure(), null, convertedEnclosing);
} else {
convertedType = originalType;
}
}
if (TypeBinding.notEquals(originalType, convertedType)) {
return dimension > 0 ? (TypeBinding)createArrayType(convertedType, dimension) : convertedType;
}
return type;
}
public ReferenceBinding[] convertToRawTypes(ReferenceBinding[] originalTypes, boolean forceErasure, boolean forceRawEnclosingType) {
if (originalTypes == null) return null;
ReferenceBinding[] convertedTypes = originalTypes;
for (int i = 0, length = originalTypes.length; i < length; i++) {
ReferenceBinding originalType = originalTypes[i];
ReferenceBinding convertedType = (ReferenceBinding) convertToRawType(forceErasure ? originalType.erasure() : originalType, forceRawEnclosingType);
if (TypeBinding.notEquals(convertedType, originalType)) {
if (convertedTypes == originalTypes) {
System.arraycopy(originalTypes, 0, convertedTypes = new ReferenceBinding[length], 0, i);
}
convertedTypes[i] = convertedType;
} else if (convertedTypes != originalTypes) {
convertedTypes[i] = originalType;
}
}
return convertedTypes;
}
public TypeBinding convertUnresolvedBinaryToRawType(TypeBinding type) {
int dimension;
TypeBinding originalType;
switch(type.kind()) {
case Binding.BASE_TYPE :
case Binding.TYPE_PARAMETER:
case Binding.WILDCARD_TYPE:
case Binding.INTERSECTION_TYPE:
case Binding.RAW_TYPE:
return type;
case Binding.ARRAY_TYPE:
dimension = type.dimensions();
originalType = type.leafComponentType();
break;
default:
if (type.id == TypeIds.T_JavaLangObject)
return type;
dimension = 0;
originalType = type;
}
boolean needToConvert;
switch (originalType.kind()) {
case Binding.BASE_TYPE :
return type;
case Binding.GENERIC_TYPE :
needToConvert = true;
break;
case Binding.PARAMETERIZED_TYPE :
ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) originalType;
needToConvert = paramType.genericType().isGenericType();
break;
default :
needToConvert = false;
break;
}
ReferenceBinding originalEnclosing = originalType.enclosingType();
TypeBinding convertedType;
if (originalEnclosing == null) {
convertedType = needToConvert ? createRawType((ReferenceBinding)originalType.erasure(), null) : originalType;
} else {
if (!needToConvert && originalType.isStatic())
return originalType;
ReferenceBinding convertedEnclosing = (ReferenceBinding) convertUnresolvedBinaryToRawType(originalEnclosing);
if (TypeBinding.notEquals(convertedEnclosing, originalEnclosing)) {
needToConvert = true;
}
if (needToConvert) {
convertedType = createRawType((ReferenceBinding) originalType.erasure(), convertedEnclosing);
} else {
convertedType = originalType;
}
}
if (TypeBinding.notEquals(originalType, convertedType)) {
return dimension > 0 ? (TypeBinding)createArrayType(convertedType, dimension) : convertedType;
}
return type;
}
public AnnotationBinding createAnnotation(ReferenceBinding annotationType, ElementValuePair[] pairs) {
if (pairs.length != 0) {
AnnotationBinding.setMethodBindings(annotationType, pairs);
return new AnnotationBinding(annotationType, pairs);
}
return this.typeSystem.getAnnotationType(annotationType, true);
}
public AnnotationBinding createUnresolvedAnnotation(ReferenceBinding annotationType, ElementValuePair[] pairs) {
if (pairs.length != 0) {
return new UnresolvedAnnotationBinding(annotationType, pairs, this);
}
return this.typeSystem.getAnnotationType(annotationType, false);
}
public ArrayBinding createArrayType(TypeBinding leafComponentType, int dimensionCount) {
return this.typeSystem.getArrayType(leafComponentType, dimensionCount);
}
public ArrayBinding createArrayType(TypeBinding leafComponentType, int dimensionCount, AnnotationBinding [] annotations) {
return this.typeSystem.getArrayType(leafComponentType, dimensionCount, annotations);
}
public TypeBinding createIntersectionType18(ReferenceBinding[] intersectingTypes) {
if (!intersectingTypes[0].isClass()) {
Arrays.sort(intersectingTypes, new Comparator<TypeBinding>() {
@Override
public int compare(TypeBinding o1, TypeBinding o2) {
return o1.isClass() ? -1 : (o2.isClass() ? 1 : CharOperation.compareTo(o1.readableName(), o2.readableName()));
}
});
}
return this.typeSystem.getIntersectionType18(intersectingTypes);
}
public BinaryTypeBinding createBinaryTypeFrom(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
return createBinaryTypeFrom(binaryType, packageBinding, true, accessRestriction);
}
public BinaryTypeBinding createBinaryTypeFrom(IBinaryType binaryType, PackageBinding packageBinding, boolean needFieldsAndMethods, AccessRestriction accessRestriction) {
if (this != packageBinding.environment)
return packageBinding.environment.createBinaryTypeFrom(binaryType, packageBinding, needFieldsAndMethods, accessRestriction);
BinaryTypeBinding binaryBinding = new BinaryTypeBinding(packageBinding, binaryType, this);
ReferenceBinding cachedType = packageBinding.getType0(binaryBinding.compoundName[binaryBinding.compoundName.length - 1]);
if (cachedType != null && !cachedType.isUnresolvedType()) {
if (cachedType.isBinaryBinding())
return (BinaryTypeBinding) cachedType;
return null;
}
packageBinding.addType(binaryBinding);
setAccessRestriction(binaryBinding, accessRestriction);
binaryBinding.cachePartsFrom(binaryType, needFieldsAndMethods);
return binaryBinding;
}
public MissingTypeBinding createMissingType(PackageBinding packageBinding, char[][] compoundName) {
if (packageBinding == null) {
packageBinding = computePackageFrom(compoundName, true );
if (packageBinding == TheNotFoundPackage) packageBinding = this.defaultPackage;
}
MissingTypeBinding missingType = new MissingTypeBinding(packageBinding, compoundName, this);
if (missingType.id != TypeIds.T_JavaLangObject) {
ReferenceBinding objectType = getType(TypeConstants.JAVA_LANG_OBJECT, javaBaseModule());
if (objectType == null) {
objectType = createMissingType(null, TypeConstants.JAVA_LANG_OBJECT);
}
missingType.setMissingSuperclass(objectType);
}
packageBinding.addType(missingType);
if (this.missingTypes == null)
this.missingTypes = new ArrayList(3);
this.missingTypes.add(missingType);
return missingType;
}
public PackageBinding createPackage(char[][] compoundName) {
return createPlainPackage(compoundName);
}
public PlainPackageBinding createPlainPackage(char[][] compoundName) {
PackageBinding packageBinding = this.module.getDeclaredPackage(CharOperation.concatWith(compoundName, '.'));
if (packageBinding != null && packageBinding.isValidBinding()) {
packageBinding = this.getTopLevelPackage(compoundName[0]);
} else {
packageBinding = getPackage0(compoundName[0]);
if (packageBinding == null || packageBinding == TheNotFoundPackage) {
packageBinding = this.module.getOrCreateDeclaredPackage(new char[][] {compoundName[0]});
if (this.useModuleSystem) {
char[][] declaringModuleNames = null;
if (this.module.isUnnamed()) {
IModuleAwareNameEnvironment moduleEnv = (IModuleAwareNameEnvironment) this.nameEnvironment;
declaringModuleNames = moduleEnv.getUniqueModulesDeclaringPackage(new char[][] {packageBinding.readableName()}, ModuleBinding.ANY);
}
packageBinding = this.module.combineWithPackagesFromOtherRelevantModules(packageBinding, packageBinding.compoundName, declaringModuleNames);
}
this.knownPackages.put(compoundName[0], packageBinding);
}
}
for (int i = 1, length = compoundName.length; i < length; i++) {
if (packageBinding.hasType0Any(compoundName[i]))
return null;
PackageBinding parent = packageBinding;
if ((packageBinding = parent.getPackage0(compoundName[i])) == null || packageBinding == TheNotFoundPackage) {
if(this.nameEnvironment instanceof INameEnvironmentExtension) {
if (((INameEnvironmentExtension)this.nameEnvironment).findType(compoundName[i], parent.compoundName, false, this.module.nameForLookup()) != null) {
return null;
}
} else {
if (this.nameEnvironment.findType(compoundName[i], parent.compoundName) != null) {
return null;
}
}
PackageBinding singleParent = parent.getIncarnation(this.module);
if (singleParent != parent && singleParent != null) {
packageBinding = singleParent.getPackage0(compoundName[i]);
}
if (packageBinding == null) {
packageBinding = this.module.createDeclaredPackage(CharOperation.subarray(compoundName, 0, i + 1), parent);
packageBinding = parent.addPackage(packageBinding, this.module);
}
}
}
return packageBinding.getIncarnation(this.module);
}
public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, RawTypeBinding rawType) {
ParameterizedGenericMethodBinding[] cachedInfo = (ParameterizedGenericMethodBinding[])this.uniqueParameterizedGenericMethodBindings.get(genericMethod);
boolean needToGrow = false;
int index = 0;
if (cachedInfo != null){
nextCachedMethod :
for (int max = cachedInfo.length; index < max; index++){
ParameterizedGenericMethodBinding cachedMethod = cachedInfo[index];
if (cachedMethod == null) break nextCachedMethod;
if (!cachedMethod.isRaw) continue nextCachedMethod;
if (cachedMethod.declaringClass != (rawType == null ? genericMethod.declaringClass : rawType)) continue nextCachedMethod;
return cachedMethod;
}
needToGrow = true;
} else {
cachedInfo = new ParameterizedGenericMethodBinding[5];
this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
}
int length = cachedInfo.length;
if (needToGrow && index == length){
System.arraycopy(cachedInfo, 0, cachedInfo = new ParameterizedGenericMethodBinding[length*2], 0, length);
this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
}
ParameterizedGenericMethodBinding parameterizedGenericMethod = new ParameterizedGenericMethodBinding(genericMethod, rawType, this);
cachedInfo[index] = parameterizedGenericMethod;
return parameterizedGenericMethod;
}
public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, TypeBinding[] typeArguments) {
return createParameterizedGenericMethod(genericMethod, typeArguments, null);
}
public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, TypeBinding[] typeArguments, TypeBinding targetType) {
return createParameterizedGenericMethod(genericMethod, typeArguments, false, false, targetType);
}
public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, TypeBinding[] typeArguments,
boolean inferredWithUncheckedConversion, boolean hasReturnProblem, TypeBinding targetType)
{
ParameterizedGenericMethodBinding[] cachedInfo = (ParameterizedGenericMethodBinding[])this.uniqueParameterizedGenericMethodBindings.get(genericMethod);
int argLength = typeArguments == null ? 0: typeArguments.length;
boolean needToGrow = false;
int index = 0;
if (cachedInfo != null){
nextCachedMethod :
for (int max = cachedInfo.length; index < max; index++){
ParameterizedGenericMethodBinding cachedMethod = cachedInfo[index];
if (cachedMethod == null) break nextCachedMethod;
if (cachedMethod.isRaw) continue nextCachedMethod;
if (cachedMethod.targetType != targetType) continue nextCachedMethod;
if (cachedMethod.inferredWithUncheckedConversion != inferredWithUncheckedConversion) continue nextCachedMethod;
TypeBinding[] cachedArguments = cachedMethod.typeArguments;
int cachedArgLength = cachedArguments == null ? 0 : cachedArguments.length;
if (argLength != cachedArgLength) continue nextCachedMethod;
for (int j = 0; j < cachedArgLength; j++){
if (typeArguments[j] != cachedArguments[j]) continue nextCachedMethod;
}
if (inferredWithUncheckedConversion) {
if (cachedMethod.returnType.isParameterizedType() || cachedMethod.returnType.isTypeVariable()) continue;
for (TypeBinding exc : cachedMethod.thrownExceptions)
if (exc.isParameterizedType() || exc.isTypeVariable()) continue nextCachedMethod;
}
return cachedMethod;
}
needToGrow = true;
} else {
cachedInfo = new ParameterizedGenericMethodBinding[5];
this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
}
int length = cachedInfo.length;
if (needToGrow && index == length){
System.arraycopy(cachedInfo, 0, cachedInfo = new ParameterizedGenericMethodBinding[length*2], 0, length);
this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
}
ParameterizedGenericMethodBinding parameterizedGenericMethod =
new ParameterizedGenericMethodBinding(genericMethod, typeArguments, this, inferredWithUncheckedConversion, hasReturnProblem, targetType);
cachedInfo[index] = parameterizedGenericMethod;
return parameterizedGenericMethod;
}
public PolymorphicMethodBinding createPolymorphicMethod(MethodBinding originalPolymorphicMethod, TypeBinding[] parameters, Scope scope) {
String key = new String(originalPolymorphicMethod.selector);
PolymorphicMethodBinding[] cachedInfo = (PolymorphicMethodBinding[]) this.uniquePolymorphicMethodBindings.get(key);
int parametersLength = parameters == null ? 0: parameters.length;
TypeBinding[] parametersTypeBinding = new TypeBinding[parametersLength];
for (int i = 0; i < parametersLength; i++) {
TypeBinding parameterTypeBinding = parameters[i];
if (parameterTypeBinding.id == TypeIds.T_null) {
parametersTypeBinding[i] = getType(JAVA_LANG_VOID, javaBaseModule());
} else {
if (parameterTypeBinding.isPolyType()) {
PolyTypeBinding ptb = (PolyTypeBinding) parameterTypeBinding;
if (scope instanceof BlockScope && ptb.expression.resolvedType == null) {
ptb.expression.setExpectedType(scope.getJavaLangObject());
parametersTypeBinding[i] = ptb.expression.resolveType((BlockScope) scope);
} else {
parametersTypeBinding[i] = ptb.expression.resolvedType;
}
} else {
parametersTypeBinding[i] = parameterTypeBinding.erasure();
}
}
}
boolean needToGrow = false;
int index = 0;
if (cachedInfo != null) {
nextCachedMethod :
for (int max = cachedInfo.length; index < max; index++) {
PolymorphicMethodBinding cachedMethod = cachedInfo[index];
if (cachedMethod == null) {
break nextCachedMethod;
}
if (cachedMethod.matches(parametersTypeBinding, originalPolymorphicMethod.returnType)) {
return cachedMethod;
}
}
needToGrow = true;
} else {
cachedInfo = new PolymorphicMethodBinding[5];
this.uniquePolymorphicMethodBindings.put(key, cachedInfo);
}
int length = cachedInfo.length;
if (needToGrow && index == length) {
System.arraycopy(cachedInfo, 0, cachedInfo = new PolymorphicMethodBinding[length*2], 0, length);
this.uniquePolymorphicMethodBindings.put(key, cachedInfo);
}
PolymorphicMethodBinding polymorphicMethod = new PolymorphicMethodBinding(
originalPolymorphicMethod,
parametersTypeBinding);
cachedInfo[index] = polymorphicMethod;
return polymorphicMethod;
}
public boolean usesAnnotatedTypeSystem() {
return this.typeSystem.isAnnotatedTypeSystem();
}
public MethodBinding updatePolymorphicMethodReturnType(PolymorphicMethodBinding binding, TypeBinding typeBinding) {
String key = new String(binding.selector);
PolymorphicMethodBinding[] cachedInfo = (PolymorphicMethodBinding[]) this.uniquePolymorphicMethodBindings.get(key);
boolean needToGrow = false;
int index = 0;
TypeBinding[] parameters = binding.parameters;
if (cachedInfo != null) {
nextCachedMethod :
for (int max = cachedInfo.length; index < max; index++) {
PolymorphicMethodBinding cachedMethod = cachedInfo[index];
if (cachedMethod == null) {
break nextCachedMethod;
}
if (cachedMethod.matches(parameters, typeBinding)) {
return cachedMethod;
}
}
needToGrow = true;
} else {
cachedInfo = new PolymorphicMethodBinding[5];
this.uniquePolymorphicMethodBindings.put(key, cachedInfo);
}
int length = cachedInfo.length;
if (needToGrow && index == length) {
System.arraycopy(cachedInfo, 0, cachedInfo = new PolymorphicMethodBinding[length*2], 0, length);
this.uniquePolymorphicMethodBindings.put(key, cachedInfo);
}
PolymorphicMethodBinding polymorphicMethod = new PolymorphicMethodBinding(
binding.original(),
typeBinding,
parameters);
cachedInfo[index] = polymorphicMethod;
return polymorphicMethod;
}
public ParameterizedMethodBinding createGetClassMethod(TypeBinding receiverType, MethodBinding originalMethod, Scope scope) {
ParameterizedMethodBinding retVal = null;
if (this.uniqueGetClassMethodBinding == null) {
this.uniqueGetClassMethodBinding = new SimpleLookupTable(3);
} else {
retVal = (ParameterizedMethodBinding)this.uniqueGetClassMethodBinding.get(receiverType);
}
if (retVal == null) {
retVal = ParameterizedMethodBinding.instantiateGetClass(receiverType, originalMethod, scope);
this.uniqueGetClassMethodBinding.put(receiverType, retVal);
}
return retVal;
}
public ReferenceBinding createMemberType(ReferenceBinding memberType, ReferenceBinding enclosingType) {
return this.typeSystem.getMemberType(memberType, enclosingType);
}
public ParameterizedTypeBinding createParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, ReferenceBinding enclosingType) {
AnnotationBinding[] annotations = genericType.typeAnnotations;
if (annotations != Binding.NO_ANNOTATIONS)
return this.typeSystem.getParameterizedType((ReferenceBinding) genericType.unannotated(), typeArguments, enclosingType, annotations);
return this.typeSystem.getParameterizedType(genericType, typeArguments, enclosingType);
}
public ParameterizedTypeBinding createParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, ReferenceBinding enclosingType, AnnotationBinding [] annotations) {
return this.typeSystem.getParameterizedType(genericType, typeArguments, enclosingType, annotations);
}
public ReferenceBinding maybeCreateParameterizedType(ReferenceBinding nonGenericType, ReferenceBinding enclosingType) {
boolean canSeeEnclosingTypeParameters = enclosingType != null
&& (enclosingType.isParameterizedType() | enclosingType.isRawType())
&& !nonGenericType.isStatic();
if (canSeeEnclosingTypeParameters)
return createParameterizedType(nonGenericType, null, enclosingType);
return nonGenericType;
}
public TypeBinding createAnnotatedType(TypeBinding type, AnnotationBinding[][] annotations) {
return this.typeSystem.getAnnotatedType(type, annotations);
}
public TypeBinding createAnnotatedType(TypeBinding type, AnnotationBinding[] newbies) {
final int newLength = newbies == null ? 0 : newbies.length;
if (type == null || newLength == 0)
return type;
AnnotationBinding [] oldies = type.getTypeAnnotations();
final int oldLength = oldies == null ? 0 : oldies.length;
if (oldLength > 0) {
System.arraycopy(newbies, 0, newbies = new AnnotationBinding[newLength + oldLength], 0, newLength);
System.arraycopy(oldies, 0, newbies, newLength, oldLength);
}
if (this.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
long tagBitsSeen = 0;
AnnotationBinding[] filtered = new AnnotationBinding[newbies.length];
int count = 0;
for (int i = 0; i < newbies.length; i++) {
if (newbies[i] == null) {
filtered[count++] = null;
tagBitsSeen = 0;
continue;
}
long tagBits = 0;
if (newbies[i].type.hasNullBit(TypeIds.BitNonNullAnnotation)) {
tagBits = TagBits.AnnotationNonNull;
} else if (newbies[i].type.hasNullBit(TypeIds.BitNullableAnnotation)) {
tagBits = TagBits.AnnotationNullable;
}
if ((tagBitsSeen & tagBits) == 0) {
tagBitsSeen |= tagBits;
filtered[count++] = newbies[i];
}
}
if (count < newbies.length)
System.arraycopy(filtered, 0, newbies = new AnnotationBinding[count], 0, count);
}
return this.typeSystem.getAnnotatedType(type, new AnnotationBinding [][] { newbies });
}
public RawTypeBinding createRawType(ReferenceBinding genericType, ReferenceBinding enclosingType) {
AnnotationBinding[] annotations = genericType.typeAnnotations;
if (annotations != Binding.NO_ANNOTATIONS)
return this.typeSystem.getRawType((ReferenceBinding) genericType.unannotated(), enclosingType, annotations);
return this.typeSystem.getRawType(genericType, enclosingType);
}
public RawTypeBinding createRawType(ReferenceBinding genericType, ReferenceBinding enclosingType, AnnotationBinding [] annotations) {
return this.typeSystem.getRawType(genericType, enclosingType, annotations);
}
public WildcardBinding createWildcard(ReferenceBinding genericType, int rank, TypeBinding bound, TypeBinding[] otherBounds, int boundKind) {
if (genericType != null) {
AnnotationBinding[] annotations = genericType.typeAnnotations;
if (annotations != Binding.NO_ANNOTATIONS)
return this.typeSystem.getWildcard((ReferenceBinding) genericType.unannotated(), rank, bound, otherBounds, boundKind, annotations);
}
return this.typeSystem.getWildcard(genericType, rank, bound, otherBounds, boundKind);
}
public CaptureBinding createCapturedWildcard(WildcardBinding wildcard, ReferenceBinding contextType, int start, int end, ASTNode cud, int id) {
return this.typeSystem.getCapturedWildcard(wildcard, contextType, start, end, cud, id);
}
public WildcardBinding createWildcard(ReferenceBinding genericType, int rank, TypeBinding bound, TypeBinding[] otherBounds, int boundKind, AnnotationBinding [] annotations) {
return this.typeSystem.getWildcard(genericType, rank, bound, otherBounds, boundKind, annotations);
}
public AccessRestriction getAccessRestriction(TypeBinding type) {
return (AccessRestriction) this.accessRestrictions.get(type);
}
public ReferenceBinding getCachedType(char[][] compoundName) {
ReferenceBinding result = getCachedType0(compoundName);
if (result == null && this.useModuleSystem) {
ModuleBinding[] modulesToSearch = this.module.isUnnamed() || this.module.isAuto
? this.root.knownModules.valueTable
: this.module.getAllRequiredModules();
for (ModuleBinding someModule : modulesToSearch) {
if (someModule == null) continue;
result = someModule.environment.getCachedType0(compoundName);
if (result != null && result.isValidBinding())
break;
}
}
return result;
}
public ReferenceBinding getCachedType0(char[][] compoundName) {
if (compoundName.length == 1) {
return this.defaultPackage.getType0(compoundName[0]);
}
PackageBinding packageBinding = getPackage0(compoundName[0]);
if (packageBinding == null || packageBinding == TheNotFoundPackage)
return null;
packageBinding = packageBinding.getIncarnation(this.module);
if (packageBinding == null || packageBinding == TheNotFoundPackage)
return null;
for (int i = 1, packageLength = compoundName.length - 1; i < packageLength; i++)
if ((packageBinding = packageBinding.getPackage0Any(compoundName[i])) == null || packageBinding == TheNotFoundPackage)
return null;
return packageBinding.getType0(compoundName[compoundName.length - 1]);
}
public AnnotationBinding getNullableAnnotation() {
if (this.nullableAnnotation != null)
return this.nullableAnnotation;
if (this.root != this) {
return this.nullableAnnotation = this.root.getNullableAnnotation();
}
ReferenceBinding nullable = getResolvedType(this.globalOptions.nullableAnnotationName, null);
return this.nullableAnnotation = this.typeSystem.getAnnotationType(nullable, true);
}
public char[][] getNullableAnnotationName() {
return this.globalOptions.nullableAnnotationName;
}
public AnnotationBinding getNonNullAnnotation() {
if (this.nonNullAnnotation != null)
return this.nonNullAnnotation;
if (this.root != this) {
return this.nonNullAnnotation = this.root.getNonNullAnnotation();
}
ReferenceBinding nonNull = getResolvedType(this.globalOptions.nonNullAnnotationName, null);
return this.nonNullAnnotation = this.typeSystem.getAnnotationType(nonNull, true);
}
public AnnotationBinding[] nullAnnotationsFromTagBits(long nullTagBits) {
if (nullTagBits == TagBits.AnnotationNonNull)
return new AnnotationBinding[] { getNonNullAnnotation() };
else if (nullTagBits == TagBits.AnnotationNullable)
return new AnnotationBinding[] { getNullableAnnotation() };
return null;
}
public char[][] getNonNullAnnotationName() {
return this.globalOptions.nonNullAnnotationName;
}
public char[][] getNonNullByDefaultAnnotationName() {
return this.globalOptions.nonNullByDefaultAnnotationName;
}
int getNullAnnotationBit(char[][] qualifiedTypeName) {
if (this.allNullAnnotations == null) {
this.allNullAnnotations = new HashMap<>();
this.allNullAnnotations.put(CharOperation.toString(this.globalOptions.nonNullAnnotationName), TypeIds.BitNonNullAnnotation);
this.allNullAnnotations.put(CharOperation.toString(this.globalOptions.nullableAnnotationName), TypeIds.BitNullableAnnotation);
this.allNullAnnotations.put(CharOperation.toString(this.globalOptions.nonNullByDefaultAnnotationName), TypeIds.BitNonNullByDefaultAnnotation);
for (String name : this.globalOptions.nullableAnnotationSecondaryNames)
this.allNullAnnotations.put(name, TypeIds.BitNullableAnnotation);
for (String name : this.globalOptions.nonNullAnnotationSecondaryNames)
this.allNullAnnotations.put(name, TypeIds.BitNonNullAnnotation);
for (String name : this.globalOptions.nonNullByDefaultAnnotationSecondaryNames)
this.allNullAnnotations.put(name, TypeIds.BitNonNullByDefaultAnnotation);
}
String qualifiedTypeString = CharOperation.toString(qualifiedTypeName);
Integer typeBit = this.allNullAnnotations.get(qualifiedTypeString);
return typeBit == null ? 0 : typeBit;
}
public boolean isNullnessAnnotationPackage(PackageBinding pkg) {
return this.nonnullAnnotationPackage == pkg || this.nullableAnnotationPackage == pkg || this.nonnullByDefaultAnnotationPackage == pkg;
}
public boolean usesNullTypeAnnotations() {
if(this.root != this) {
return this.root.usesNullTypeAnnotations();
}
if (this.globalOptions.useNullTypeAnnotations != null)
return this.globalOptions.useNullTypeAnnotations;
initializeUsesNullTypeAnnotation();
for (MethodBinding enumMethod : this.deferredEnumMethods) {
int purpose = 0;
if (CharOperation.equals(enumMethod.selector, TypeConstants.VALUEOF)) {
purpose = SyntheticMethodBinding.EnumValueOf;
} else if (CharOperation.equals(enumMethod.selector, TypeConstants.VALUES)) {
purpose = SyntheticMethodBinding.EnumValues;
}
if (purpose != 0)
SyntheticMethodBinding.markNonNull(enumMethod, purpose, this);
}
this.deferredEnumMethods.clear();
return this.globalOptions.useNullTypeAnnotations;
}
private void initializeUsesNullTypeAnnotation() {
this.globalOptions.useNullTypeAnnotations = Boolean.FALSE;
if (!this.globalOptions.isAnnotationBasedNullAnalysisEnabled || this.globalOptions.originalSourceLevel < ClassFileConstants.JDK1_8)
return;
ReferenceBinding nullable;
ReferenceBinding nonNull;
boolean origMayTolerateMissingType = this.mayTolerateMissingType;
this.mayTolerateMissingType = true;
try {
nullable = this.nullableAnnotation != null ? this.nullableAnnotation.getAnnotationType()
: getType(this.getNullableAnnotationName(), this.UnNamedModule);
nonNull = this.nonNullAnnotation != null ? this.nonNullAnnotation.getAnnotationType()
: getType(this.getNonNullAnnotationName(), this.UnNamedModule);
} finally {
this.mayTolerateMissingType = origMayTolerateMissingType;
}
if (nullable == null && nonNull == null)
return;
if (nullable == null || nonNull == null)
return;
long nullableMetaBits = nullable.getAnnotationTagBits() & TagBits.AnnotationForTypeUse;
long nonNullMetaBits = nonNull.getAnnotationTagBits() & TagBits.AnnotationForTypeUse;
if (nullableMetaBits != nonNullMetaBits)
return;
if (nullableMetaBits == 0)
return;
this.globalOptions.useNullTypeAnnotations = Boolean.TRUE;
}
PackageBinding getPackage0(char[] name) {
return this.knownPackages.get(name);
}
public ReferenceBinding getResolvedType(char[][] compoundName, Scope scope) {
return getResolvedType(compoundName, scope == null ? this.UnNamedModule : scope.module(), scope);
}
public ReferenceBinding getResolvedType(char[][] compoundName, ModuleBinding moduleBinding, Scope scope) {
if (this.module != moduleBinding)
return moduleBinding.environment.getResolvedType(compoundName, moduleBinding, scope);
ReferenceBinding type = getType(compoundName, moduleBinding);
if (type != null) return type;
this.problemReporter.isClassPathCorrect(
compoundName,
scope == null ? this.root.unitBeingCompleted : scope.referenceCompilationUnit(),
this.missingClassFileLocation);
return createMissingType(null, compoundName);
}
public ReferenceBinding getResolvedJavaBaseType(char[][] compoundName, Scope scope) {
return getResolvedType(compoundName, javaBaseModule(), scope);
}
PackageBinding getTopLevelPackage(char[] name) {
if (this.useModuleSystem) {
return this.module.getTopLevelPackage(name);
}
PackageBinding packageBinding = getPackage0(name);
if (packageBinding != null) {
if (packageBinding == TheNotFoundPackage)
return null;
return packageBinding;
}
if (this.nameEnvironment.isPackage(null, name)) {
this.knownPackages.put(name, packageBinding = this.module.createDeclaredToplevelPackage(name));
return packageBinding;
}
this.knownPackages.put(name, TheNotFoundPackage);
return null;
}
public ReferenceBinding getType(char[][] compoundName) {
return getType(compoundName, this.UnNamedModule);
}
public ReferenceBinding getType(char[][] compoundName, ModuleBinding mod) {
ReferenceBinding referenceBinding;
if (compoundName.length == 1) {
if ((referenceBinding = this.defaultPackage.getType0(compoundName[0])) == null) {
PackageBinding packageBinding = getPackage0(compoundName[0]);
if (packageBinding != null && packageBinding != TheNotFoundPackage)
return null;
referenceBinding = askForType(this.defaultPackage, compoundName[0], mod);
}
} else {
PackageBinding packageBinding = getPackage0(compoundName[0]);
if (packageBinding == TheNotFoundPackage)
return null;
if (packageBinding != null) {
for (int i = 1, packageLength = compoundName.length - 1; i < packageLength; i++) {
if ((packageBinding = packageBinding.getPackage0(compoundName[i])) == null)
break;
if (packageBinding == TheNotFoundPackage)
return null;
}
}
if (packageBinding == null)
referenceBinding = askForType(compoundName, mod);
else if ((referenceBinding = packageBinding.getType0(compoundName[compoundName.length - 1])) == null)
referenceBinding = askForType(packageBinding, compoundName[compoundName.length - 1], mod);
}
if (referenceBinding == null || referenceBinding == TheNotFoundType)
return null;
referenceBinding = (ReferenceBinding) BinaryTypeBinding.resolveType(referenceBinding, this, false );
return referenceBinding;
}
private TypeBinding[] getTypeArgumentsFromSignature(SignatureWrapper wrapper, TypeVariableBinding[] staticVariables, ReferenceBinding enclosingType, ReferenceBinding genericType,
char[][][] missingTypeNames, ITypeAnnotationWalker walker)
{
java.util.ArrayList args = new java.util.ArrayList(2);
int rank = 0;
do {
args.add(getTypeFromVariantTypeSignature(wrapper, staticVariables, enclosingType, genericType, rank, missingTypeNames,
walker.toTypeArgument(rank++)));
} while (wrapper.signature[wrapper.start] != '>');
wrapper.start++;
TypeBinding[] typeArguments = new TypeBinding[args.size()];
args.toArray(typeArguments);
return typeArguments;
}
private ReferenceBinding getTypeFromCompoundName(char[][] compoundName, boolean isParameterized, boolean wasMissingType) {
ReferenceBinding binding = getCachedType(compoundName);
if (binding == null) {
PackageBinding packageBinding = computePackageFrom(compoundName, false );
if(this.useModuleSystem) {
binding = packageBinding.getType0(compoundName[compoundName.length - 1]);
}
if(binding == null) {
binding = new UnresolvedReferenceBinding(compoundName, packageBinding);
if (wasMissingType) {
binding.tagBits |= TagBits.HasMissingType;
}
packageBinding.addType(binding);
}
}
if (binding == TheNotFoundType) {
if (!wasMissingType) {
this.problemReporter.isClassPathCorrect(compoundName, this.root.unitBeingCompleted, this.missingClassFileLocation);
}
binding = createMissingType(null, compoundName);
} else if (!isParameterized) {
binding = (ReferenceBinding) convertUnresolvedBinaryToRawType(binding);
}
return binding;
}
ReferenceBinding getTypeFromConstantPoolName(char[] signature, int start, int end, boolean isParameterized, char[][][] missingTypeNames, ITypeAnnotationWalker walker) {
if (end == -1)
end = signature.length;
char[][] compoundName = CharOperation.splitOn('/', signature, start, end);
boolean wasMissingType = false;
if (missingTypeNames != null) {
for (int i = 0, max = missingTypeNames.length; i < max; i++) {
if (CharOperation.equals(compoundName, missingTypeNames[i])) {
wasMissingType = true;
break;
}
}
}
ReferenceBinding binding = getTypeFromCompoundName(compoundName, isParameterized, wasMissingType);
if (walker != ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
binding = (ReferenceBinding) annotateType(binding, walker, missingTypeNames);
}
return binding;
}
ReferenceBinding getTypeFromConstantPoolName(char[] signature, int start, int end, boolean isParameterized, char[][][] missingTypeNames) {
return getTypeFromConstantPoolName(signature, start, end, isParameterized, missingTypeNames, ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER);
}
TypeBinding getTypeFromSignature(char[] signature, int start, int end, boolean isParameterized, TypeBinding enclosingType,
char[][][] missingTypeNames, ITypeAnnotationWalker walker)
{
int dimension = 0;
while (signature[start] == '[') {
start++;
dimension++;
}
AnnotationBinding [][] annotationsOnDimensions = null;
if (dimension > 0 && walker != ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
for (int i = 0; i < dimension; i++) {
AnnotationBinding [] annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(0, true), this, missingTypeNames);
if (annotations != Binding.NO_ANNOTATIONS) {
if (annotationsOnDimensions == null)
annotationsOnDimensions = new AnnotationBinding[dimension][];
annotationsOnDimensions[i] = annotations;
}
walker = walker.toNextArrayDimension();
}
}
if (end == -1)
end = signature.length - 1;
TypeBinding binding = null;
if (start == end) {
switch (signature[start]) {
case 'I' :
binding = TypeBinding.INT;
break;
case 'Z' :
binding = TypeBinding.BOOLEAN;
break;
case 'V' :
binding = TypeBinding.VOID;
break;
case 'C' :
binding = TypeBinding.CHAR;
break;
case 'D' :
binding = TypeBinding.DOUBLE;
break;
case 'B' :
binding = TypeBinding.BYTE;
break;
case 'F' :
binding = TypeBinding.FLOAT;
break;
case 'J' :
binding = TypeBinding.LONG;
break;
case 'S' :
binding = TypeBinding.SHORT;
break;
default :
this.problemReporter.corruptedSignature(enclosingType, signature, start);
}
} else {
binding = getTypeFromConstantPoolName(signature, start + 1, end, isParameterized, missingTypeNames);
}
if (isParameterized) {
if (dimension != 0)
throw new IllegalStateException();
return binding;
}
if (walker != ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
binding = annotateType(binding, walker, missingTypeNames);
}
if (dimension != 0)
binding = this.typeSystem.getArrayType(binding, dimension, AnnotatableTypeSystem.flattenedAnnotations(annotationsOnDimensions));
return binding;
}
private TypeBinding annotateType(TypeBinding binding, ITypeAnnotationWalker walker, char[][][] missingTypeNames) {
if (walker == ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
return binding;
}
int depth = binding.depth() + 1;
if (depth > 1) {
if (binding.isUnresolvedType())
binding = ((UnresolvedReferenceBinding) binding).resolve(this, true);
depth = countNonStaticNestingLevels(binding) + 1;
}
AnnotationBinding [][] annotations = null;
for (int i = 0; i < depth; i++) {
AnnotationBinding[] annots = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(binding.id, i == depth - 1), this, missingTypeNames);
if (annots != null && annots.length > 0) {
if (annotations == null)
annotations = new AnnotationBinding[depth][];
annotations[i] = annots;
}
walker = walker.toNextNestedType();
}
if (annotations != null)
binding = createAnnotatedType(binding, annotations);
return binding;
}
private int countNonStaticNestingLevels(TypeBinding binding) {
if (binding.isUnresolvedType()) {
throw new IllegalStateException();
}
int depth = -1;
TypeBinding currentBinding = binding;
while (currentBinding != null) {
depth++;
if (currentBinding.isStatic())
break;
currentBinding = currentBinding.enclosingType();
}
return depth;
}
boolean qualifiedNameMatchesSignature(char[][] name, char[] signature) {
int s = 1;
for (int i = 0; i < name.length; i++) {
char[] n = name[i];
for (int j = 0; j < n.length; j++)
if (n[j] != signature[s++])
return false;
if (signature[s] == ';' && i == name.length-1)
return true;
if (signature[s++] != '/')
return false;
}
return false;
}
public TypeBinding getTypeFromTypeSignature(SignatureWrapper wrapper, TypeVariableBinding[] staticVariables, ReferenceBinding enclosingType,
char[][][] missingTypeNames, ITypeAnnotationWalker walker)
{
int dimension = 0;
while (wrapper.signature[wrapper.start] == '[') {
wrapper.start++;
dimension++;
}
AnnotationBinding [][] annotationsOnDimensions = null;
if (dimension > 0 && walker != ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER) {
for (int i = 0; i < dimension; i++) {
AnnotationBinding [] annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(0, true), this, missingTypeNames);
if (annotations != Binding.NO_ANNOTATIONS) {
if (annotationsOnDimensions == null)
annotationsOnDimensions = new AnnotationBinding[dimension][];
annotationsOnDimensions[i] = annotations;
}
walker = walker.toNextArrayDimension();
}
}
if (wrapper.signature[wrapper.start] == 'T') {
int varStart = wrapper.start + 1;
int varEnd = wrapper.computeEnd();
for (int i = staticVariables.length; --i >= 0;)
if (CharOperation.equals(staticVariables[i].sourceName, wrapper.signature, varStart, varEnd))
return getTypeFromTypeVariable(staticVariables[i], dimension, annotationsOnDimensions, walker, missingTypeNames);
ReferenceBinding initialType = enclosingType;
do {
TypeVariableBinding[] enclosingTypeVariables;
if (enclosingType instanceof BinaryTypeBinding) {
enclosingTypeVariables = ((BinaryTypeBinding)enclosingType).typeVariables;
} else {
enclosingTypeVariables = enclosingType.typeVariables();
}
for (int i = enclosingTypeVariables.length; --i >= 0;)
if (CharOperation.equals(enclosingTypeVariables[i].sourceName, wrapper.signature, varStart, varEnd))
return getTypeFromTypeVariable(enclosingTypeVariables[i], dimension, annotationsOnDimensions, walker, missingTypeNames);
} while ((enclosingType = enclosingType.enclosingType()) != null);
this.problemReporter.undefinedTypeVariableSignature(CharOperation.subarray(wrapper.signature, varStart, varEnd), initialType);
return null;
}
boolean isParameterized;
TypeBinding type = getTypeFromSignature(wrapper.signature, wrapper.start, wrapper.computeEnd(), isParameterized = (wrapper.end == wrapper.bracket), enclosingType, missingTypeNames, walker);
if (!isParameterized)
return dimension == 0 ? type : createArrayType(type, dimension, AnnotatableTypeSystem.flattenedAnnotations(annotationsOnDimensions));
ReferenceBinding actualType = (ReferenceBinding) type;
if (walker != ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER && actualType instanceof UnresolvedReferenceBinding)
if (actualType.depth() > 0)
actualType = (ReferenceBinding) BinaryTypeBinding.resolveType(actualType, this, false );
ReferenceBinding actualEnclosing = actualType.enclosingType();
ITypeAnnotationWalker savedWalker = walker;
if(walker != ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER && actualType.depth() > 0) {
int nonStaticNestingLevels = countNonStaticNestingLevels(actualType);
for (int i = 0; i < nonStaticNestingLevels; i++) {
walker = walker.toNextNestedType();
}
}
TypeBinding[] typeArguments = getTypeArgumentsFromSignature(wrapper, staticVariables, enclosingType, actualType, missingTypeNames, walker);
ReferenceBinding currentType = createParameterizedType(actualType, typeArguments, actualEnclosing);
ReferenceBinding plainCurrent = actualType;
while (wrapper.signature[wrapper.start] == '.') {
wrapper.start++;
int memberStart = wrapper.start;
char[] memberName = wrapper.nextWord();
plainCurrent = (ReferenceBinding) BinaryTypeBinding.resolveType(plainCurrent, this, false);
ReferenceBinding memberType = plainCurrent.getMemberType(memberName);
if (memberType == null)
this.problemReporter.corruptedSignature(currentType, wrapper.signature, memberStart);
if(memberType.isStatic()) {
walker = savedWalker;
} else {
walker = walker.toNextNestedType();
}
if (wrapper.signature[wrapper.start] == '<') {
wrapper.start++;
typeArguments = getTypeArgumentsFromSignature(wrapper, staticVariables, enclosingType, memberType, missingTypeNames, walker);
} else {
typeArguments = null;
}
if (typeArguments != null ||
(!memberType.isStatic() && currentType.isParameterizedType()))
{
if (memberType.isStatic())
currentType = plainCurrent;
currentType = createParameterizedType(memberType, typeArguments, currentType);
} else {
currentType = memberType;
}
plainCurrent = memberType;
}
wrapper.start++;
TypeBinding annotatedType = annotateType(currentType, savedWalker, missingTypeNames);
return dimension == 0 ? annotatedType : createArrayType(annotatedType, dimension, AnnotatableTypeSystem.flattenedAnnotations(annotationsOnDimensions));
}
private TypeBinding getTypeFromTypeVariable(TypeVariableBinding typeVariableBinding, int dimension, AnnotationBinding [][] annotationsOnDimensions, ITypeAnnotationWalker walker, char [][][] missingTypeNames) {
AnnotationBinding [] annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(-1, false), this, missingTypeNames);
if (annotations != null && annotations != Binding.NO_ANNOTATIONS)
typeVariableBinding = (TypeVariableBinding) createAnnotatedType(typeVariableBinding, new AnnotationBinding [][] { annotations });
if (dimension == 0) {
return typeVariableBinding;
}
return this.typeSystem.getArrayType(typeVariableBinding, dimension, AnnotatableTypeSystem.flattenedAnnotations(annotationsOnDimensions));
}
TypeBinding getTypeFromVariantTypeSignature(
SignatureWrapper wrapper,
TypeVariableBinding[] staticVariables,
ReferenceBinding enclosingType,
ReferenceBinding genericType,
int rank,
char[][][] missingTypeNames,
ITypeAnnotationWalker walker) {
switch (wrapper.signature[wrapper.start]) {
case '-' :
wrapper.start++;
TypeBinding bound = getTypeFromTypeSignature(wrapper, staticVariables, enclosingType, missingTypeNames, walker.toWildcardBound());
AnnotationBinding [] annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(-1, false), this, missingTypeNames);
return this.typeSystem.getWildcard(genericType, rank, bound, null , Wildcard.SUPER, annotations);
case '+' :
wrapper.start++;
bound = getTypeFromTypeSignature(wrapper, staticVariables, enclosingType, missingTypeNames, walker.toWildcardBound());
annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(-1, false), this, missingTypeNames);
return this.typeSystem.getWildcard(genericType, rank, bound, null , Wildcard.EXTENDS, annotations);
case '*' :
wrapper.start++;
annotations = BinaryTypeBinding.createAnnotations(walker.getAnnotationsAtCursor(-1, false), this, missingTypeNames);
return this.typeSystem.getWildcard(genericType, rank, null, null , Wildcard.UNBOUND, annotations);
default :
return getTypeFromTypeSignature(wrapper, staticVariables, enclosingType, missingTypeNames, walker);
}
}
boolean isMissingType(char[] typeName) {
for (int i = this.missingTypes == null ? 0 : this.missingTypes.size(); --i >= 0;) {
MissingTypeBinding missingType = (MissingTypeBinding) this.missingTypes.get(i);
if (CharOperation.equals(missingType.sourceName, typeName))
return true;
}
return false;
}
public MethodVerifier methodVerifier() {
if (this.verifier == null)
this.verifier = newMethodVerifier();
return this.verifier;
}
public MethodVerifier newMethodVerifier() {
return new MethodVerifier15(this);
}
public void releaseClassFiles(org.eclipse.jdt.internal.compiler.ClassFile[] classFiles) {
for (int i = 0, fileCount = classFiles.length; i < fileCount; i++)
this.classFilePool.release(classFiles[i]);
}
public void reset() {
if (this.root != this) {
this.root.reset();
return;
}
this.stepCompleted = 0;
this.knownModules = new HashtableOfModule();
this.UnNamedModule = new ModuleBinding.UnNamedModule(this);
this.module = this.UnNamedModule;
this.JavaBaseModule = null;
this.defaultPackage = new PlainPackageBinding(this);
this.defaultImports = null;
this.knownPackages = new HashtableOfPackage();
this.accessRestrictions = new HashMap(3);
this.verifier = null;
this.uniqueParameterizedGenericMethodBindings = new SimpleLookupTable(3);
this.uniquePolymorphicMethodBindings = new SimpleLookupTable(3);
this.uniqueGetClassMethodBinding = null;
this.missingTypes = null;
this.typesBeingConnected = new HashSet();
for (int i = this.units.length; --i >= 0;)
this.units[i] = null;
this.lastUnitIndex = -1;
this.lastCompletedUnitIndex = -1;
this.unitBeingCompleted = null;
this.classFilePool.reset();
this.typeSystem.reset();
}
public void setAccessRestriction(ReferenceBinding type, AccessRestriction accessRestriction) {
if (accessRestriction == null) return;
type.modifiers |= ExtraCompilerModifiers.AccRestrictedAccess;
this.accessRestrictions.put(type, accessRestriction);
}
void updateCaches(UnresolvedReferenceBinding unresolvedType, ReferenceBinding resolvedType) {
this.typeSystem.updateCaches(unresolvedType, resolvedType);
}
public IQualifiedTypeResolutionListener[] resolutionListeners;
public void addResolutionListener(IQualifiedTypeResolutionListener resolutionListener) {
synchronized (this.root) {
int length = this.root.resolutionListeners.length;
for (int i = 0; i < length; i++){
if (this.root.resolutionListeners[i].equals(resolutionListener))
return;
}
System.arraycopy(this.root.resolutionListeners, 0,
this.root.resolutionListeners = new IQualifiedTypeResolutionListener[length + 1], 0, length);
this.root.resolutionListeners[length] = resolutionListener;
}
}
public TypeBinding getUnannotatedType(TypeBinding typeBinding) {
return this.typeSystem.getUnannotatedType(typeBinding);
}
public TypeBinding[] getAnnotatedTypes(TypeBinding type) {
return this.typeSystem.getAnnotatedTypes(type);
}
public AnnotationBinding[] filterNullTypeAnnotations(AnnotationBinding[] typeAnnotations) {
if (typeAnnotations.length == 0)
return typeAnnotations;
AnnotationBinding[] filtered = new AnnotationBinding[typeAnnotations.length];
int count = 0;
for (int i = 0; i < typeAnnotations.length; i++) {
AnnotationBinding typeAnnotation = typeAnnotations[i];
if (typeAnnotation == null) {
count++;
} else {
if (!typeAnnotation.type.hasNullBit(TypeIds.BitNonNullAnnotation|TypeIds.BitNullableAnnotation))
filtered[count++] = typeAnnotation;
}
}
if (count == 0)
return Binding.NO_ANNOTATIONS;
if (count == typeAnnotations.length)
return typeAnnotations;
System.arraycopy(filtered, 0, filtered = new AnnotationBinding[count], 0, count);
return filtered;
}
public boolean containsNullTypeAnnotation(IBinaryAnnotation[] typeAnnotations) {
if (typeAnnotations.length == 0)
return false;
for (int i = 0; i < typeAnnotations.length; i++) {
IBinaryAnnotation typeAnnotation = typeAnnotations[i];
char[] typeName = typeAnnotation.getTypeName();
if (typeName == null || typeName.length < 3 || typeName[0] != 'L') continue;
char[][] name = CharOperation.splitOn('/', typeName, 1, typeName.length-1);
if (getNullAnnotationBit(name) != 0)
return true;
}
return false;
}
public boolean containsNullTypeAnnotation(AnnotationBinding[] typeAnnotations) {
if (typeAnnotations.length == 0)
return false;
for (int i = 0; i < typeAnnotations.length; i++) {
AnnotationBinding typeAnnotation = typeAnnotations[i];
if (typeAnnotation.type.hasNullBit(TypeIds.BitNonNullAnnotation|TypeIds.BitNullableAnnotation))
return true;
}
return false;
}
public Binding getInaccessibleBinding(char[][] compoundName, ModuleBinding clientModule) {
if (this.root != this)
return this.root.getInaccessibleBinding(compoundName, clientModule);
if (this.nameEnvironment instanceof IModuleAwareNameEnvironment) {
IModuleAwareNameEnvironment moduleEnv = (IModuleAwareNameEnvironment) this.nameEnvironment;
int length = compoundName.length;
for (int j=length; j>0; j--) {
char[][] candidateName = CharOperation.subarray(compoundName, 0, j);
char[][] moduleNames = moduleEnv.getModulesDeclaringPackage(candidateName, ModuleBinding.ANY);
if (moduleNames != null) {
PackageBinding inaccessiblePackage = null;
for (char[] moduleName : moduleNames) {
if (moduleName == ModuleBinding.UNOBSERVABLE)
continue;
ModuleBinding mod = getModule(moduleName);
if (mod != null) {
PackageBinding pack = mod.getVisiblePackage(candidateName);
if (pack != null && pack.isValidBinding()) {
if (clientModule.canAccess(pack))
return null;
inaccessiblePackage = pack;
}
}
}
if (inaccessiblePackage == null)
return null;
if (j < length) {
TypeBinding type = inaccessiblePackage.getType(compoundName[j], inaccessiblePackage.enclosingModule);
if (type instanceof ReferenceBinding && type.isValidBinding())
return new ProblemReferenceBinding(compoundName, (ReferenceBinding) type, ProblemReasons.NotAccessible);
}
return new ProblemPackageBinding(candidateName, ProblemReasons.NotAccessible, this);
}
}
}
return null;
}
}
LookupEnvironment
accessRestrictions: Map
defaultImports: ImportBinding[]
