package org.eclipse.jdt.internal.core;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.search.*;
import org.eclipse.jdt.internal.codeassist.ISearchRequestor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
import org.eclipse.jdt.internal.compiler.env.IBinaryType;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.env.IModule;
import org.eclipse.jdt.internal.compiler.env.IModule.IModuleReference;
import org.eclipse.jdt.internal.compiler.env.IModule.IPackageExport;
import org.eclipse.jdt.internal.compiler.env.IModuleAwareNameEnvironment;
import org.eclipse.jdt.internal.compiler.env.ISourceType;
import org.eclipse.jdt.internal.compiler.env.IUpdatableModule;
import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
import org.eclipse.jdt.internal.compiler.env.IUpdatableModule.UpdateKind;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.lookup.ModuleBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.core.NameLookup.Answer;
import org.eclipse.jdt.internal.core.search.BasicSearchEngine;
import org.eclipse.jdt.internal.core.search.IRestrictedAccessConstructorRequestor;
import org.eclipse.jdt.internal.core.search.IRestrictedAccessTypeRequestor;
import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.jdt.internal.core.search.processing.IJob;
import org.eclipse.jdt.internal.core.util.Util;
public class SearchableEnvironment
implements IModuleAwareNameEnvironment, IJavaSearchConstants {
public NameLookup nameLookup;
protected ICompilationUnit unitToSkip;
protected org.eclipse.jdt.core.ICompilationUnit[] workingCopies;
protected WorkingCopyOwner owner;
protected JavaProject project;
protected IJavaSearchScope searchScope;
protected boolean checkAccessRestrictions;
private Map<String,IPackageFragmentRoot[]> knownModuleLocations;
private boolean excludeTestCode;
private ModuleUpdater moduleUpdater;
private Map<IPackageFragmentRoot,IModuleDescription> rootToModule;
@Deprecated
public SearchableEnvironment(JavaProject project, org.eclipse.jdt.core.ICompilationUnit[] workingCopies) throws JavaModelException {
this(project, workingCopies, false);
}
public SearchableEnvironment(JavaProject project, org.eclipse.jdt.core.ICompilationUnit[] workingCopies, boolean excludeTestCode) throws JavaModelException {
this.project = project;
this.excludeTestCode = excludeTestCode;
this.checkAccessRestrictions =
!JavaCore.IGNORE.equals(project.getOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, true))
|| !JavaCore.IGNORE.equals(project.getOption(JavaCore.COMPILER_PB_DISCOURAGED_REFERENCE, true));
this.workingCopies = workingCopies;
this.nameLookup = project.newNameLookup(workingCopies, excludeTestCode);
if (CompilerOptions.versionToJdkLevel(project.getOption(JavaCore.COMPILER_COMPLIANCE, true)) >= ClassFileConstants.JDK9) {
this.knownModuleLocations = new HashMap<>();
}
if (CompilerOptions.versionToJdkLevel(project.getOption(JavaCore.COMPILER_COMPLIANCE, true)) >= ClassFileConstants.JDK9) {
this.moduleUpdater = new ModuleUpdater(project);
if (!excludeTestCode) {
IClasspathEntry[] expandedClasspath = project.getExpandedClasspath();
if(Arrays.stream(expandedClasspath).anyMatch(e -> e.isTest())) {
this.moduleUpdater.addReadUnnamedForNonEmptyClasspath(project, expandedClasspath);
}
}
for (IClasspathEntry entry : project.getRawClasspath())
if(!excludeTestCode || !entry.isTest())
this.moduleUpdater.computeModuleUpdates(entry);
}
}
@Deprecated
public SearchableEnvironment(JavaProject project, WorkingCopyOwner owner) throws JavaModelException {
this(project, owner, false);
}
public SearchableEnvironment(JavaProject project, WorkingCopyOwner owner, boolean excludeTestCode) throws JavaModelException {
this(project, owner == null ? null : JavaModelManager.getJavaModelManager().getWorkingCopies(owner, true), excludeTestCode);
this.owner = owner;
}
private static int convertSearchFilterToModelFilter(int searchFilter) {
switch (searchFilter) {
case IJavaSearchConstants.CLASS:
return NameLookup.ACCEPT_CLASSES;
case IJavaSearchConstants.INTERFACE:
return NameLookup.ACCEPT_INTERFACES;
case IJavaSearchConstants.ENUM:
return NameLookup.ACCEPT_ENUMS;
case IJavaSearchConstants.ANNOTATION_TYPE:
return NameLookup.ACCEPT_ANNOTATIONS;
case IJavaSearchConstants.CLASS_AND_ENUM:
return NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_ENUMS;
case IJavaSearchConstants.CLASS_AND_INTERFACE:
return NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES;
default:
return NameLookup.ACCEPT_ALL;
}
}
protected NameEnvironmentAnswer find(String typeName, String packageName, IPackageFragmentRoot[] moduleContext) {
if (packageName == null)
packageName = IPackageFragment.DEFAULT_PACKAGE_NAME;
if (this.owner != null) {
String source = this.owner.findSource(typeName, packageName);
if (source != null) {
IJavaElement moduleElement = (moduleContext != null && moduleContext.length > 0) ? moduleContext[0] : null;
ICompilationUnit cu = new BasicCompilationUnit(
source.toCharArray(),
CharOperation.splitOn('.', packageName.toCharArray()),
typeName + Util.defaultJavaExtension(),
moduleElement);
return new NameEnvironmentAnswer(cu, null);
}
}
NameLookup.Answer answer =
this.nameLookup.findType(
typeName,
packageName,
false,
NameLookup.ACCEPT_ALL,
this.checkAccessRestrictions,
moduleContext);
if (answer != null) {
if (answer.type instanceof BinaryType) {
try {
char[] moduleName = answer.module != null ? answer.module.getElementName().toCharArray() : null;
return new NameEnvironmentAnswer((IBinaryType) ((BinaryType) answer.type).getElementInfo(), answer.restriction, moduleName);
} catch (JavaModelException npe) {
}
} else {
try {
SourceTypeElementInfo sourceType = (SourceTypeElementInfo)((SourceType) answer.type).getElementInfo();
ISourceType topLevelType = sourceType;
while (topLevelType.getEnclosingType() != null) {
topLevelType = topLevelType.getEnclosingType();
}
IType[] types = sourceType.getHandle().getCompilationUnit().getTypes();
ISourceType[] sourceTypes = new ISourceType[types.length];
sourceTypes[0] = sourceType;
int length = types.length;
for (int i = 0, index = 1; i < length; i++) {
ISourceType otherType =
(ISourceType) ((JavaElement) types[i]).getElementInfo();
if (!otherType.equals(topLevelType) && index < length)
sourceTypes[index++] = otherType;
}
char[] moduleName = answer.module != null ? answer.module.getElementName().toCharArray() : null;
return new NameEnvironmentAnswer(sourceTypes, answer.restriction, getExternalAnnotationPath(answer.entry), moduleName);
} catch (JavaModelException jme) {
if (jme.isDoesNotExist() && String.valueOf(TypeConstants.PACKAGE_INFO_NAME).equals(typeName)) {
return new NameEnvironmentAnswer((ICompilationUnit)answer.type.getParent(), answer.restriction);
}
}
}
}
return null;
}
private String getExternalAnnotationPath(IClasspathEntry entry) {
if (entry == null)
return null;
IPath path = ClasspathEntry.getExternalAnnotationPath(entry, this.project.getProject(), true);
if (path == null)
return null;
return path.toOSString();
}
public void findModules(char[] prefix, ISearchRequestor requestor, IJavaProject javaProject) {
this.nameLookup.seekModule(prefix, true, new SearchableEnvironmentRequestor(requestor));
}
public void findPackages(char[] prefix, ISearchRequestor requestor) {
this.nameLookup.seekPackageFragments(
new String(prefix),
true,
new SearchableEnvironmentRequestor(requestor));
}
public void findPackages(char[] prefix, ISearchRequestor requestor, IPackageFragmentRoot[] moduleContext, boolean followRequires) {
this.nameLookup.seekPackageFragments(
new String(prefix),
true,
new SearchableEnvironmentRequestor(requestor), moduleContext);
if (followRequires && this.knownModuleLocations != null) {
try {
boolean isMatchAllPrefix = CharOperation.equals(CharOperation.ALL_PREFIX, prefix);
Set<IModuleDescription> modDescs = new HashSet<>();
for (IPackageFragmentRoot root : moduleContext) {
IModuleDescription desc = root.getJavaProject().getModuleDescription();
if (desc instanceof AbstractModule)
modDescs.add(desc);
}
for (IModuleDescription md : modDescs) {
IModuleReference[] reqModules = ((AbstractModule) md).getRequiredModules();
char[] modName = md.getElementName().toCharArray();
for (IModuleReference moduleReference : reqModules) {
findPackagesFromRequires(prefix, isMatchAllPrefix, requestor, moduleReference, modName);
}
}
} catch (JavaModelException e) {
}
}
}
private void findPackagesFromRequires(char[] prefix, boolean isMatchAllPrefix, ISearchRequestor requestor, IModuleReference moduleReference, char[] clientModuleName) {
IPackageFragmentRoot[] fragmentRoots = findModuleContext(moduleReference.name());
if (fragmentRoots == null) return;
for (IPackageFragmentRoot root : fragmentRoots) {
IJavaProject requiredProject = root.getJavaProject();
try {
IModuleDescription module = requiredProject.getModuleDescription();
if (module instanceof AbstractModule) {
AbstractModule requiredModule = (AbstractModule) module;
for (IPackageExport packageExport : requiredModule.getExportedPackages()) {
if (!packageExport.isQualified() || CharOperation.containsEqual(packageExport.targets(), clientModuleName)) {
char[] exportName = packageExport.name();
if (isMatchAllPrefix || CharOperation.prefixEquals(prefix, exportName))
requestor.acceptPackage(exportName);
}
}
for (IModuleReference moduleRef2 : requiredModule.getRequiredModules()) {
if (moduleRef2.isTransitive())
findPackagesFromRequires(prefix, isMatchAllPrefix, requestor, moduleRef2, clientModuleName);
}
}
} catch (JavaModelException e) {
}
}
}
public void findExactTypes(char[] name, final boolean findMembers, int searchFor, final ISearchRequestor storage) {
try {
final String excludePath;
if (this.unitToSkip != null) {
if (!(this.unitToSkip instanceof IJavaElement)) {
findExactTypes(
new String(name),
storage,
convertSearchFilterToModelFilter(searchFor));
return;
}
excludePath = ((IJavaElement) this.unitToSkip).getPath().toString();
} else {
excludePath = null;
}
IProgressMonitor progressMonitor = new IProgressMonitor() {
boolean isCanceled = false;
@Override
public void beginTask(String n, int totalWork) {
}
@Override
public void done() {
}
@Override
public void internalWorked(double work) {
}
@Override
public boolean isCanceled() {
return this.isCanceled;
}
@Override
public void setCanceled(boolean value) {
this.isCanceled = value;
}
@Override
public void setTaskName(String n) {
}
@Override
public void subTask(String n) {
}
@Override
public void worked(int work) {
}
};
IRestrictedAccessTypeRequestor typeRequestor = new IRestrictedAccessTypeRequestor() {
@Override
public void acceptType(int modifiers, char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, String path, AccessRestriction access) {
if (excludePath != null && excludePath.equals(path))
return;
if (!findMembers && enclosingTypeNames != null && enclosingTypeNames.length > 0)
return;
storage.acceptType(packageName, simpleTypeName, enclosingTypeNames, modifiers, access);
}
};
try {
new BasicSearchEngine(this.workingCopies).searchAllTypeNames(
null,
SearchPattern.R_EXACT_MATCH,
name,
SearchPattern.R_EXACT_MATCH,
searchFor,
getSearchScope(),
typeRequestor,
CANCEL_IF_NOT_READY_TO_SEARCH,
progressMonitor);
} catch (OperationCanceledException e) {
findExactTypes(
new String(name),
storage,
convertSearchFilterToModelFilter(searchFor));
}
} catch (JavaModelException e) {
findExactTypes(
new String(name),
storage,
convertSearchFilterToModelFilter(searchFor));
}
}
private void findExactTypes(String name, ISearchRequestor storage, int type) {
SearchableEnvironmentRequestor requestor =
new SearchableEnvironmentRequestor(storage, this.unitToSkip, this.project, this.nameLookup);
this.nameLookup.seekTypes(name, null, false, type, requestor);
}
public NameEnvironmentAnswer findTypeInModules(char[][] compoundTypeName, ModuleBinding module) {
char[] nameForLookup = module.nameForLookup();
NameEnvironmentAnswer answer = findType(compoundTypeName, nameForLookup);
if (answer != null)
return answer;
if (LookupStrategy.get(nameForLookup) == LookupStrategy.Named) {
for (ModuleBinding required : module.getAllRequiredModules()) {
answer = findType(compoundTypeName, required.nameForLookup());
if (answer != null)
return answer;
}
}
return null;
}
@Override
public NameEnvironmentAnswer findType(char[][] compoundTypeName, char[] moduleName) {
if (compoundTypeName == null) return null;
boolean isNamedStrategy = LookupStrategy.get(moduleName) == LookupStrategy.Named;
IPackageFragmentRoot[] moduleLocations = isNamedStrategy ? findModuleContext(moduleName) : null;
int length = compoundTypeName.length;
if (length <= 1) {
if (length == 0) return null;
return find(new String(compoundTypeName[0]), null, moduleLocations);
}
int lengthM1 = length - 1;
char[][] packageName = new char[lengthM1][];
System.arraycopy(compoundTypeName, 0, packageName, 0, lengthM1);
return find(
new String(compoundTypeName[lengthM1]),
CharOperation.toString(packageName),
moduleLocations);
}
@Override
public NameEnvironmentAnswer findType(char[] name, char[][] packageName, char[] moduleName) {
if (name == null) return null;
boolean isNamedStrategy = LookupStrategy.get(moduleName) == LookupStrategy.Named;
IPackageFragmentRoot[] moduleLocations = isNamedStrategy ? findModuleContext(moduleName) : null;
return find(
new String(name),
packageName == null || packageName.length == 0 ? null : CharOperation.toString(packageName),
moduleLocations);
}
public void findTypes(char[] prefix, final boolean findMembers, boolean camelCaseMatch, int searchFor, final ISearchRequestor storage) {
findTypes(prefix, findMembers, camelCaseMatch, searchFor, storage, null);
}
public void findTypes(char[] prefix, final boolean findMembers, boolean camelCaseMatch, int searchFor, final ISearchRequestor storage, IProgressMonitor monitor) {
try {
final String excludePath;
if (this.unitToSkip != null) {
if (!(this.unitToSkip instanceof IJavaElement)) {
findTypes(
new String(prefix),
storage,
convertSearchFilterToModelFilter(searchFor));
return;
}
excludePath = ((IJavaElement) this.unitToSkip).getPath().toString();
} else {
excludePath = null;
}
int lastDotIndex = CharOperation.lastIndexOf('.', prefix);
char[] qualification, simpleName;
if (lastDotIndex < 0) {
qualification = null;
if (camelCaseMatch) {
simpleName = prefix;
} else {
simpleName = CharOperation.toLowerCase(prefix);
}
} else {
qualification = CharOperation.subarray(prefix, 0, lastDotIndex);
if (camelCaseMatch) {
simpleName = CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length);
} else {
simpleName =
CharOperation.toLowerCase(
CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length));
}
}
IProgressMonitor progressMonitor = new IProgressMonitor() {
boolean isCanceled = false;
@Override
public void beginTask(String name, int totalWork) {
}
@Override
public void done() {
}
@Override
public void internalWorked(double work) {
}
@Override
public boolean isCanceled() {
return this.isCanceled;
}
@Override
public void setCanceled(boolean value) {
this.isCanceled = value;
}
@Override
public void setTaskName(String name) {
}
@Override
public void subTask(String name) {
}
@Override
public void worked(int work) {
}
};
IRestrictedAccessTypeRequestor typeRequestor = new IRestrictedAccessTypeRequestor() {
@Override
public void acceptType(int modifiers, char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, String path, AccessRestriction access) {
if (excludePath != null && excludePath.equals(path))
return;
if (!findMembers && enclosingTypeNames != null && enclosingTypeNames.length > 0)
return;
storage.acceptType(packageName, simpleTypeName, enclosingTypeNames, modifiers, access);
}
};
int matchRule = SearchPattern.R_PREFIX_MATCH;
if (camelCaseMatch) matchRule |= SearchPattern.R_CAMELCASE_MATCH;
if (monitor != null) {
IndexManager indexManager = JavaModelManager.getIndexManager();
if (indexManager.awaitingJobsCount() == 0) {
new BasicSearchEngine(this.workingCopies).searchAllTypeNames(
qualification,
SearchPattern.R_EXACT_MATCH,
simpleName,
matchRule,
searchFor,
getSearchScope(),
typeRequestor,
FORCE_IMMEDIATE_SEARCH,
progressMonitor);
} else {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
if (monitor.isCanceled()) {
throw new OperationCanceledException();
}
if (indexManager.awaitingJobsCount() == 0) {
new BasicSearchEngine(this.workingCopies).searchAllTypeNames(
qualification,
SearchPattern.R_EXACT_MATCH,
simpleName,
matchRule,
searchFor,
getSearchScope(),
typeRequestor,
FORCE_IMMEDIATE_SEARCH,
progressMonitor);
} else {
findTypes(
new String(prefix),
storage,
convertSearchFilterToModelFilter(searchFor));
}
}
} else {
try {
new BasicSearchEngine(this.workingCopies).searchAllTypeNames(
qualification,
SearchPattern.R_EXACT_MATCH,
simpleName,
matchRule,
searchFor,
getSearchScope(),
typeRequestor,
CANCEL_IF_NOT_READY_TO_SEARCH,
progressMonitor);
} catch (OperationCanceledException e) {
findTypes(
new String(prefix),
storage,
convertSearchFilterToModelFilter(searchFor));
}
}
} catch (JavaModelException e) {
findTypes(
new String(prefix),
storage,
convertSearchFilterToModelFilter(searchFor));
}
}
public void findConstructorDeclarations(char[] prefix, boolean camelCaseMatch, final ISearchRequestor storage, IProgressMonitor monitor) {
try {
final String excludePath;
if (this.unitToSkip != null && this.unitToSkip instanceof IJavaElement) {
excludePath = ((IJavaElement) this.unitToSkip).getPath().toString();
} else {
excludePath = null;
}
int lastDotIndex = CharOperation.lastIndexOf('.', prefix);
char[] qualification, simpleName;
if (lastDotIndex < 0) {
qualification = null;
if (camelCaseMatch) {
simpleName = prefix;
} else {
simpleName = CharOperation.toLowerCase(prefix);
}
} else {
qualification = CharOperation.subarray(prefix, 0, lastDotIndex);
if (camelCaseMatch) {
simpleName = CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length);
} else {
simpleName =
CharOperation.toLowerCase(
CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length));
}
}
IProgressMonitor progressMonitor = new IProgressMonitor() {
boolean isCanceled = false;
@Override
public void beginTask(String name, int totalWork) {
}
@Override
public void done() {
}
@Override
public void internalWorked(double work) {
}
@Override
public boolean isCanceled() {
return this.isCanceled;
}
@Override
public void setCanceled(boolean value) {
this.isCanceled = value;
}
@Override
public void setTaskName(String name) {
}
@Override
public void subTask(String name) {
}
@Override
public void worked(int work) {
}
};
IRestrictedAccessConstructorRequestor constructorRequestor = new IRestrictedAccessConstructorRequestor() {
@Override
public void acceptConstructor(
int modifiers,
char[] simpleTypeName,
int parameterCount,
char[] signature,
char[][] parameterTypes,
char[][] parameterNames,
int typeModifiers,
char[] packageName,
int extraFlags,
String path,
AccessRestriction access) {
if (excludePath != null && excludePath.equals(path))
return;
storage.acceptConstructor(
modifiers,
simpleTypeName,
parameterCount,
signature,
parameterTypes,
parameterNames,
typeModifiers,
packageName,
extraFlags,
path,
access);
}
};
int matchRule = SearchPattern.R_PREFIX_MATCH;
if (camelCaseMatch) matchRule |= SearchPattern.R_CAMELCASE_MATCH;
if (monitor != null) {
IndexManager indexManager = JavaModelManager.getIndexManager();
indexManager.performConcurrentJob(new IJob() {
@Override
public boolean belongsTo(String jobFamily) {
return true;
}
@Override
public void cancel() {
}
@Override
public void ensureReadyToRun() {
}
@Override
public boolean execute(IProgressMonitor progress) {
return progress == null || !progress.isCanceled();
}
@Override
public String getJobFamily() {
return "";
}
}, IJob.WaitUntilReady, monitor);
new BasicSearchEngine(this.workingCopies).searchAllConstructorDeclarations(
qualification,
simpleName,
matchRule,
getSearchScope(),
constructorRequestor,
FORCE_IMMEDIATE_SEARCH,
progressMonitor);
} else {
try {
new BasicSearchEngine(this.workingCopies).searchAllConstructorDeclarations(
qualification,
simpleName,
matchRule,
getSearchScope(),
constructorRequestor,
CANCEL_IF_NOT_READY_TO_SEARCH,
progressMonitor);
} catch (OperationCanceledException e) {
}
}
} catch (JavaModelException e) {
}
}
private void findTypes(String prefix, ISearchRequestor storage, int type) {
SearchableEnvironmentRequestor requestor =
new SearchableEnvironmentRequestor(storage, this.unitToSkip, this.project, this.nameLookup);
int index = prefix.lastIndexOf('.');
if (index == -1) {
this.nameLookup.seekTypes(prefix, null, true, type, requestor);
} else {
String packageName = prefix.substring(0, index);
JavaElementRequestor elementRequestor = new JavaElementRequestor();
this.nameLookup.seekPackageFragments(packageName, false, elementRequestor);
IPackageFragment[] fragments = elementRequestor.getPackageFragments();
if (fragments != null) {
String className = prefix.substring(index + 1);
for (int i = 0, length = fragments.length; i < length; i++)
if (fragments[i] != null)
this.nameLookup.seekTypes(className, fragments[i], true, type, requestor);
}
}
}
private IJavaSearchScope getSearchScope() {
if (this.searchScope == null) {
if(this.checkAccessRestrictions) {
this.searchScope = BasicSearchEngine.createJavaSearchScope(this.excludeTestCode, new IJavaElement[] {this.project});
} else {
this.searchScope = BasicSearchEngine.createJavaSearchScope(this.excludeTestCode, this.nameLookup.packageFragmentRoots);
}
}
return this.searchScope;
}
@Override
public char[][] getModulesDeclaringPackage(char[][] packageName, char[] moduleName) {
String[] pkgName = Arrays.stream(packageName).map(String::new).toArray(String[]::new);
LookupStrategy strategy = LookupStrategy.get(moduleName);
switch (strategy) {
case Named:
if (this.knownModuleLocations != null) {
IPackageFragmentRoot[] moduleContext = findModuleContext(moduleName);
if (moduleContext != null) {
if (this.nameLookup.isPackage(pkgName, moduleContext)) {
return new char[][] { moduleName };
}
}
}
return null;
case Unnamed:
case Any:
if (this.knownModuleLocations == null) {
if ((this.owner != null && this.owner.isPackage(pkgName))
|| this.nameLookup.isPackage(pkgName))
return new char[][] { ModuleBinding.UNNAMED };
return null;
}
case AnyNamed:
char[][] names = CharOperation.NO_CHAR_CHAR;
IPackageFragmentRoot[] packageRoots = this.nameLookup.packageFragmentRoots;
boolean containsUnnamed = false;
for (IPackageFragmentRoot packageRoot : packageRoots) {
IPackageFragmentRoot[] singleton = { packageRoot };
if (strategy.matches(singleton, locs -> locs[0] instanceof JrtPackageFragmentRoot || getModuleDescription(locs) != null)) {
if (this.nameLookup.isPackage(pkgName, singleton)) {
IModuleDescription moduleDescription = getModuleDescription(singleton);
char[] aName;
if (moduleDescription != null) {
aName = moduleDescription.getElementName().toCharArray();
} else {
if (containsUnnamed)
continue;
containsUnnamed = true;
aName = ModuleBinding.UNNAMED;
}
names = CharOperation.arrayConcat(names, aName);
}
}
}
return names == CharOperation.NO_CHAR_CHAR ? null : names;
default:
throw new IllegalArgumentException("Unexpected LookupStrategy "+strategy);
}
}
@Override
public boolean hasCompilationUnit(char[][] pkgName, char[] moduleName, boolean checkCUs) {
LookupStrategy strategy = LookupStrategy.get(moduleName);
switch (strategy) {
case Named:
if (this.knownModuleLocations != null) {
IPackageFragmentRoot[] moduleContext = findModuleContext(moduleName);
if (moduleContext != null) {
if (this.nameLookup.hasCompilationUnit(pkgName, moduleContext))
return true;
}
}
return false;
case Unnamed:
case Any:
if (this.knownModuleLocations == null) {
if (this.nameLookup.hasCompilationUnit(pkgName, null))
return true;
}
case AnyNamed:
IPackageFragmentRoot[] packageRoots = this.nameLookup.packageFragmentRoots;
for (IPackageFragmentRoot packageRoot : packageRoots) {
IPackageFragmentRoot[] singleton = { packageRoot };
if (strategy.matches(singleton, locs -> locs[0] instanceof JrtPackageFragmentRoot || getModuleDescription(locs) != null)) {
if (this.nameLookup.hasCompilationUnit(pkgName, singleton))
return true;
}
}
return false;
default:
throw new IllegalArgumentException("Unexpected LookupStrategy "+strategy);
}
}
private IModuleDescription getModuleDescription(IPackageFragmentRoot[] roots) {
if (this.rootToModule == null) {
this.rootToModule = new HashMap<>();
}
for (IPackageFragmentRoot root : roots) {
IModuleDescription moduleDescription = NameLookup.getModuleDescription(this.project, root, this.rootToModule, this.nameLookup.rootToResolvedEntries::get);
if (moduleDescription != null)
return moduleDescription;
}
return null;
}
private IPackageFragmentRoot[] findModuleContext(char[] moduleName) {
IPackageFragmentRoot[] moduleContext = null;
if (this.knownModuleLocations != null && moduleName != null && moduleName.length > 0) {
moduleContext = this.knownModuleLocations.get(String.valueOf(moduleName));
if (moduleContext == null) {
Answer moduleAnswer = this.nameLookup.findModule(moduleName);
if (moduleAnswer != null) {
IProject currentProject = moduleAnswer.module.getJavaProject().getProject();
IJavaElement current = moduleAnswer.module.getParent();
while (moduleContext == null && current != null) {
switch (current.getElementType()) {
case IJavaElement.PACKAGE_FRAGMENT_ROOT:
if (!((IPackageFragmentRoot) current).isExternal() && !(current instanceof JarPackageFragmentRoot)) {
current = current.getJavaProject();
} else {
moduleContext = new IPackageFragmentRoot[] { (IPackageFragmentRoot) current };
break;
}
case IJavaElement.JAVA_PROJECT:
try {
moduleContext = getOwnedPackageFragmentRoots((IJavaProject) current);
} catch (JavaModelException e) {
}
break;
default:
current = current.getParent();
if (current != null) {
try {
IResource resource = current.getUnderlyingResource();
if (resource != null) {
IProject otherProject = resource.getProject();
if (otherProject != null && !otherProject.equals(currentProject)) {
IJavaProject otherJavaProject = JavaCore.create(otherProject);
if (otherJavaProject.exists())
moduleContext = getRootsForOutputLocation(otherJavaProject, resource);
}
}
} catch (JavaModelException e) {
Util.log(e, "Failed to find package fragment root for " + current);
}
}
}
}
this.knownModuleLocations.put(String.valueOf(moduleName), moduleContext);
}
}
}
return moduleContext;
}
protected String toStringChar(char[] name) {
return "["
+ new String(name) + "]" ;
}
protected String toStringCharChar(char[][] names) {
StringBuffer result = new StringBuffer();
for (int i = 0; i < names.length; i++) {
result.append(toStringChar(names[i]));
}
return result.toString();
}
@Override
public void cleanup() {
}
@Override
public org.eclipse.jdt.internal.compiler.env.IModule getModule(char[] name) {
NameLookup.Answer answer = this.nameLookup.findModule(name);
IModule module = null;
if (answer != null) {
module = NameLookup.getModuleDescriptionInfo(answer.module);
}
return module;
}
@Override
public char[][] getAllAutomaticModules() {
return CharOperation.NO_CHAR_CHAR;
}
@Override
public void applyModuleUpdates(IUpdatableModule module, UpdateKind kind) {
if (this.moduleUpdater != null)
this.moduleUpdater.applyModuleUpdates(module, kind);
}
private IPackageFragmentRoot[] getRootsForOutputLocation(IJavaProject otherJavaProject, IResource outputLocation) throws JavaModelException {
IPath outputPath = outputLocation.getFullPath();
List<IPackageFragmentRoot> result = new ArrayList<>();
if (outputPath.equals(otherJavaProject.getOutputLocation())) {
for (IClasspathEntry classpathEntry : otherJavaProject.getRawClasspath()) {
if (classpathEntry.getOutputLocation() == null) {
for (IPackageFragmentRoot root : otherJavaProject.findPackageFragmentRoots(classpathEntry)) {
IResource rootResource = root.getResource();
if (rootResource == null || !rootResource.getProject().equals(otherJavaProject.getProject()))
continue;
result.add(root);
}
}
}
}
if (!result.isEmpty())
return result.toArray(new IPackageFragmentRoot[result.size()]);
for (IClasspathEntry classpathEntry : otherJavaProject.getRawClasspath()) {
if (outputPath.equals(classpathEntry.getOutputLocation()))
return otherJavaProject.findPackageFragmentRoots(classpathEntry);
}
return null;
}
public static IPackageFragmentRoot[] getOwnedPackageFragmentRoots(IJavaProject javaProject) throws JavaModelException {
IPackageFragmentRoot[] allRoots = javaProject.getPackageFragmentRoots();
IPackageFragmentRoot[] sourceRoots = Arrays.copyOf(allRoots, allRoots.length);
int count = 0;
for (int i = 0; i < allRoots.length; i++) {
IPackageFragmentRoot root = allRoots[i];
if (root.getKind() == IPackageFragmentRoot.K_BINARY) {
if(root instanceof JarPackageFragmentRoot) {
continue;
}
IResource resource = root.getResource();
if (resource == null || !resource.getProject().equals(javaProject.getProject()))
continue;
}
sourceRoots[count++] = root;
}
if (count < allRoots.length)
return Arrays.copyOf(sourceRoots, count);
return sourceRoots;
}
@Override
public char[][] listPackages(char[] moduleName) {
switch (LookupStrategy.get(moduleName)) {
case Named:
IPackageFragmentRoot[] packageRoots = findModuleContext(moduleName);
Set<String> packages = new HashSet<>();
for (IPackageFragmentRoot packageRoot : packageRoots) {
try {
for (IJavaElement javaElement : packageRoot.getChildren()) {
if (javaElement instanceof IPackageFragment && !((IPackageFragment) javaElement).isDefaultPackage())
packages.add(javaElement.getElementName());
}
} catch (JavaModelException e) {
Util.log(e, "Failed to retrieve packages from " + packageRoot);
}
}
return packages.stream().map(String::toCharArray).toArray(char[][]::new);
default:
throw new UnsupportedOperationException("can list packages only of a named module");
}
}
}
SearchableEnvironment
unitToSkip: ICompilationUnit
knownModuleLocations: Map<String, IPackageFragmentRoot[]>
