@NotNull
public static <T extends PsiJavaCodeReferenceElement> JavaResolveResult[] multiResolveImpl(
@NotNull T element,
boolean incompleteCode,
@NotNull ResolveCache.PolyVariantContextResolver<? super T> resolver) {
FileASTNode fileElement = SharedImplUtil.findFileElement(element.getNode());
if (fileElement == null) {
PsiUtilCore.ensureValid(element);
LOG.error("fileElement == null!");
return JavaResolveResult.EMPTY_ARRAY;
}
PsiFile psiFile = SharedImplUtil.getContainingFile(fileElement);
PsiManager manager = psiFile == null ? null : psiFile.getManager();
if (manager == null) {
PsiUtilCore.ensureValid(element);
LOG.error("getManager() == null!");
return JavaResolveResult.EMPTY_ARRAY;
}
boolean valid = psiFile.isValid();
if (!valid) {
PsiUtilCore.ensureValid(element);
LOG.error("psiFile.isValid() == false!");
return JavaResolveResult.EMPTY_ARRAY;
}
if (element instanceof PsiMethodReferenceExpression) {
// method refs: do not cache results during parent conflict resolving, acceptable checks, etc
final Map<PsiElement, PsiType> map = LambdaUtil.ourFunctionTypes.get();
if (map != null && map.containsKey(element)) {
return (JavaResolveResult[]) resolver.resolve(element, psiFile, incompleteCode);
}
}
return multiResolveImpl(manager.getProject(), psiFile, element, incompleteCode, resolver);
}
@Override
public PsiType visitClassType(PsiClassType classType) {
final PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics();
final PsiClass aClass = resolveResult.getElement();
if (aClass == null) return classType;
PsiUtilCore.ensureValid(aClass);
if (aClass instanceof PsiTypeParameter) {
final PsiTypeParameter typeParameter = (PsiTypeParameter) aClass;
if (containsInMap(typeParameter)) {
PsiType result = substituteTypeParameter(typeParameter);
if (result != null) {
PsiUtil.ensureValidType(result);
}
return result;
}
return classType;
}
final Map<PsiTypeParameter, PsiType> hashMap = new HashMap<PsiTypeParameter, PsiType>(2);
if (!processClass(aClass, resolveResult.getSubstitutor(), hashMap)) {
return null;
}
PsiClassType result =
JavaPsiFacade.getElementFactory(aClass.getProject())
.createType(aClass, createSubstitutor(hashMap), classType.getLanguageLevel());
PsiUtil.ensureValidType(result);
return result;
}
@Override
public PsiType visitClassType(final PsiClassType classType) {
PsiClassType alreadyComputed = myResultMap.get(classType);
if (alreadyComputed != null) {
return alreadyComputed;
}
final PsiClassType.ClassResolveResult classResolveResult = classType.resolveGenerics();
final PsiClass psiClass = classResolveResult.getElement();
final PsiSubstitutor substitutor = classResolveResult.getSubstitutor();
if (psiClass == null) return classType;
PsiUtilCore.ensureValid(psiClass);
final PsiClass mappedClass = mapClass(psiClass);
if (mappedClass == null) return classType;
PsiClassType mappedType =
new PsiCorrectedClassType(
classType.getLanguageLevel(),
classType,
new CorrectedResolveResult(psiClass, mappedClass, substitutor, classResolveResult));
myResultMap.put(classType, mappedType);
return mappedType;
}
@Nullable
@Override
public Document getDocument(@NotNull PsiFile file) {
if (file instanceof PsiBinaryFile) return null;
Document document = getCachedDocument(file);
if (document != null) {
if (!file.getViewProvider().isPhysical() && document.getUserData(HARD_REF_TO_PSI) == null) {
PsiUtilCore.ensureValid(file);
cachePsi(document, file);
}
return document;
}
FileViewProvider viewProvider = file.getViewProvider();
if (!viewProvider.isEventSystemEnabled()) return null;
document = FileDocumentManager.getInstance().getDocument(viewProvider.getVirtualFile());
if (document != null) {
if (document.getTextLength() != file.getTextLength()) {
String message =
"Document/PSI mismatch: "
+ file
+ " ("
+ file.getClass()
+ "); physical="
+ viewProvider.isPhysical();
if (document.getTextLength() + file.getTextLength() < 8096) {
message +=
"\n=== document ===\n" + document.getText() + "\n=== PSI ===\n" + file.getText();
}
throw new AssertionError(message);
}
if (!viewProvider.isPhysical()) {
PsiUtilCore.ensureValid(file);
cachePsi(document, file);
file.putUserData(HARD_REF_TO_DOCUMENT, document);
}
}
return document;
}
@NotNull
public static PsiAnchor create(@NotNull final PsiElement element) {
PsiUtilCore.ensureValid(element);
PsiAnchor anchor = doCreateAnchor(element);
if (ApplicationManager.getApplication().isUnitTestMode()
&& !element.equals(anchor.retrieve())) {
LOG.error(
"Cannot restore element "
+ element
+ " of "
+ element.getClass()
+ " from anchor "
+ anchor);
}
return anchor;
}
// need to shorten references in type argument list
public static void shortenReference(final PsiFile file, final int offset)
throws IncorrectOperationException {
Project project = file.getProject();
final PsiDocumentManager manager = PsiDocumentManager.getInstance(project);
Document document = manager.getDocument(file);
if (document == null) {
PsiUtilCore.ensureValid(file);
LOG.error("No document for " + file);
return;
}
manager.commitDocument(document);
final PsiReference ref = file.findReferenceAt(offset);
if (ref != null) {
PsiElement element = ref.getElement();
if (element != null) {
JavaCodeStyleManager.getInstance(project).shortenClassReferences(element);
PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(document);
}
}
}
/** Types should be proceed by the callers themselves */
@Deprecated
public static PsiType normalizeWildcardTypeByPosition(
@NotNull PsiType type, @NotNull PsiExpression expression) {
PsiUtilCore.ensureValid(expression);
PsiUtil.ensureValidType(type);
PsiExpression topLevel = expression;
while (topLevel.getParent() instanceof PsiArrayAccessExpression
&& ((PsiArrayAccessExpression) topLevel.getParent()).getArrayExpression() == topLevel) {
topLevel = (PsiExpression) topLevel.getParent();
}
if (topLevel instanceof PsiArrayAccessExpression && !PsiUtil.isAccessedForWriting(topLevel)) {
return PsiUtil.captureToplevelWildcards(type, expression);
}
final PsiType normalized = doNormalizeWildcardByPosition(type, expression, topLevel);
LOG.assertTrue(normalized.isValid(), type);
if (normalized instanceof PsiClassType && !PsiUtil.isAccessedForWriting(topLevel)) {
return PsiUtil.captureToplevelWildcards(normalized, expression);
}
return normalized;
}
private void buildText(
@NotNull PsiClass aClass,
@NotNull PsiSubstitutor substitutor,
@NotNull StringBuilder buffer,
@NotNull TextType textType,
boolean annotated) {
if (aClass instanceof PsiAnonymousClass) {
ClassResolveResult baseResolveResult =
((PsiAnonymousClass) aClass).getBaseClassType().resolveGenerics();
PsiClass baseClass = baseResolveResult.getElement();
if (baseClass != null) {
buildText(baseClass, baseResolveResult.getSubstitutor(), buffer, textType, false);
}
return;
}
boolean qualified = textType != TextType.PRESENTABLE;
PsiClass enclosingClass = null;
if (!aClass.hasModifierProperty(PsiModifier.STATIC)) {
PsiElement parent = aClass.getParent();
if (parent instanceof PsiClass && !(parent instanceof PsiAnonymousClass)) {
enclosingClass = (PsiClass) parent;
}
}
if (enclosingClass != null) {
buildText(enclosingClass, substitutor, buffer, textType, false);
buffer.append('.');
} else if (qualified) {
String fqn = aClass.getQualifiedName();
if (fqn != null) {
String prefix = StringUtil.getPackageName(fqn);
if (!StringUtil.isEmpty(prefix)) {
buffer.append(prefix);
buffer.append('.');
}
}
}
if (annotated) {
PsiNameHelper.appendAnnotations(buffer, getAnnotations(), qualified);
}
buffer.append(aClass.getName());
PsiTypeParameter[] typeParameters = aClass.getTypeParameters();
if (typeParameters.length > 0) {
int pos = buffer.length();
buffer.append('<');
for (int i = 0; i < typeParameters.length; i++) {
PsiTypeParameter typeParameter = typeParameters[i];
PsiUtilCore.ensureValid(typeParameter);
if (i > 0) {
buffer.append(',');
if (textType == TextType.PRESENTABLE) buffer.append(' ');
}
PsiType substitutionResult = substitutor.substitute(typeParameter);
if (substitutionResult == null) {
buffer.setLength(pos);
pos = -1;
break;
}
PsiUtil.ensureValidType(substitutionResult);
if (textType == TextType.PRESENTABLE) {
buffer.append(substitutionResult.getPresentableText());
} else if (textType == TextType.CANONICAL) {
buffer.append(substitutionResult.getCanonicalText(annotated));
} else {
buffer.append(substitutionResult.getInternalCanonicalText());
}
}
if (pos >= 0) {
buffer.append('>');
}
}
}
