public static Set<PsiType> flatten(PsiType[] conjuncts, Set<PsiType> types) {
for (PsiType conjunct : conjuncts) {
if (conjunct instanceof PsiIntersectionType) {
PsiIntersectionType type = (PsiIntersectionType) conjunct;
flatten(type.getConjuncts(), types);
} else {
types.add(conjunct);
}
}
if (types.size() > 1) {
PsiType[] array = types.toArray(createArray(types.size()));
for (Iterator<PsiType> iterator = types.iterator(); iterator.hasNext(); ) {
PsiType type = iterator.next();
for (PsiType existing : array) {
if (type != existing) {
final boolean allowUncheckedConversion =
type instanceof PsiClassType && ((PsiClassType) type).isRaw();
if (TypeConversionUtil.isAssignable(type, existing, allowUncheckedConversion)) {
iterator.remove();
break;
}
}
}
}
if (types.isEmpty()) {
types.add(array[0]);
}
}
return types;
}
public static Set<LookupElement> processJavaReference(
PsiElement element,
PsiJavaReference javaReference,
ElementFilter elementFilter,
JavaCompletionProcessor.Options options,
final PrefixMatcher matcher,
CompletionParameters parameters) {
final Set<LookupElement> set = new LinkedHashSet<LookupElement>();
final Condition<String> nameCondition =
new Condition<String>() {
@Override
public boolean value(String s) {
return matcher.prefixMatches(s);
}
};
PsiMethodCallExpression call =
PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class);
boolean checkInitialized =
parameters.getInvocationCount() <= 1
&& call != null
&& PsiKeyword.SUPER.equals(call.getMethodExpression().getText());
final JavaCompletionProcessor processor =
new JavaCompletionProcessor(
element, elementFilter, options.withInitialized(checkInitialized), nameCondition);
final PsiType plainQualifier = processor.getQualifierType();
PsiType qualifierType = plainQualifier;
PsiType runtimeQualifier = getQualifierCastType(javaReference, parameters);
if (runtimeQualifier != null) {
PsiType composite =
qualifierType == null
? runtimeQualifier
: PsiIntersectionType.createIntersection(qualifierType, runtimeQualifier);
PsiElement ctx = createContextWithXxxVariable(element, composite);
javaReference =
(PsiReferenceExpression)
JavaPsiFacade.getElementFactory(element.getProject())
.createExpressionFromText("xxx.xxx", ctx);
qualifierType = runtimeQualifier;
processor.setQualifierType(qualifierType);
}
javaReference.processVariants(processor);
final PsiTypeLookupItem castItem =
runtimeQualifier == null
? null
: PsiTypeLookupItem.createLookupItem(
runtimeQualifier, (PsiReferenceExpression) javaReference);
final boolean pkgContext = inSomePackage(element);
final Set<PsiMember> mentioned = new THashSet<PsiMember>();
for (CompletionElement completionElement : processor.getResults()) {
for (LookupElement item : createLookupElements(completionElement, javaReference)) {
item.putUserData(QUALIFIER_TYPE_ATTR, qualifierType);
final Object o = item.getObject();
if (o instanceof PsiClass && !isSourceLevelAccessible(element, (PsiClass) o, pkgContext)) {
continue;
}
if (o instanceof PsiMember) {
if (isInExcludedPackage((PsiMember) o, true)) {
continue;
}
mentioned.add(CompletionUtil.getOriginalOrSelf((PsiMember) o));
}
set.add(
highlightIfNeeded(
qualifierType,
castQualifier(item, castItem, plainQualifier, processor),
o,
element));
}
}
if (javaReference instanceof PsiJavaCodeReferenceElement
&& !((PsiJavaCodeReferenceElement) javaReference).isQualified()) {
final StaticMemberProcessor memberProcessor = new JavaStaticMemberProcessor(parameters);
memberProcessor.processMembersOfRegisteredClasses(
matcher,
new PairConsumer<PsiMember, PsiClass>() {
@Override
public void consume(PsiMember member, PsiClass psiClass) {
if (!mentioned.contains(member)
&& processor.satisfies(member, ResolveState.initial())) {
set.add(memberProcessor.createLookupElement(member, psiClass, true));
}
}
});
}
return set;
}
@NotNull
private static PsiType getLeastUpperBound(
PsiType type1, PsiType type2, Set<Pair<PsiType, PsiType>> compared, PsiManager manager) {
if (type1 instanceof PsiCapturedWildcardType) {
return getLeastUpperBound(
((PsiCapturedWildcardType) type1).getUpperBound(), type2, compared, manager);
}
if (type2 instanceof PsiCapturedWildcardType) {
return getLeastUpperBound(
type1, ((PsiCapturedWildcardType) type2).getUpperBound(), compared, manager);
}
if (type1 instanceof PsiWildcardType) {
return getLeastUpperBound(
((PsiWildcardType) type1).getExtendsBound(), type2, compared, manager);
}
if (type2 instanceof PsiWildcardType) {
return getLeastUpperBound(
type1, ((PsiWildcardType) type2).getExtendsBound(), compared, manager);
}
if (type1 instanceof PsiArrayType && type2 instanceof PsiArrayType) {
final PsiType componentType1 = ((PsiArrayType) type1).getComponentType();
final PsiType componentType2 = ((PsiArrayType) type2).getComponentType();
final PsiType componentType =
getLeastUpperBound(componentType1, componentType2, compared, manager);
if (componentType1 instanceof PsiPrimitiveType
&& componentType2 instanceof PsiPrimitiveType
&& componentType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
final PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
final GlobalSearchScope resolveScope = GlobalSearchScope.allScope(manager.getProject());
final PsiClassType cloneable =
factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_CLONEABLE, resolveScope);
final PsiClassType serializable =
factory.createTypeByFQClassName(CommonClassNames.JAVA_IO_SERIALIZABLE, resolveScope);
return PsiIntersectionType.createIntersection(componentType, cloneable, serializable);
}
return componentType.createArrayType();
}
if (type1 instanceof PsiIntersectionType) {
Set<PsiType> newConjuncts = new LinkedHashSet<PsiType>();
final PsiType[] conjuncts = ((PsiIntersectionType) type1).getConjuncts();
for (PsiType type : conjuncts) {
newConjuncts.add(getLeastUpperBound(type, type2, compared, manager));
}
return PsiIntersectionType.createIntersection(
newConjuncts.toArray(PsiType.createArray(newConjuncts.size())));
}
if (type2 instanceof PsiIntersectionType) {
return getLeastUpperBound(type2, type1, compared, manager);
}
if (type1 instanceof PsiClassType && type2 instanceof PsiClassType) {
PsiClassType.ClassResolveResult classResolveResult1 =
((PsiClassType) type1).resolveGenerics();
PsiClassType.ClassResolveResult classResolveResult2 =
((PsiClassType) type2).resolveGenerics();
PsiClass aClass = classResolveResult1.getElement();
PsiClass bClass = classResolveResult2.getElement();
if (aClass == null || bClass == null) {
return PsiType.getJavaLangObject(manager, GlobalSearchScope.allScope(manager.getProject()));
}
PsiClass[] supers = getLeastUpperClasses(aClass, bClass);
if (supers.length == 0) {
return PsiType.getJavaLangObject(manager, aClass.getResolveScope());
}
PsiClassType[] conjuncts = new PsiClassType[supers.length];
for (int i = 0; i < supers.length; i++) {
PsiClass aSuper = supers[i];
PsiSubstitutor subst1 =
TypeConversionUtil.getSuperClassSubstitutor(
aSuper, aClass, classResolveResult1.getSubstitutor());
PsiSubstitutor subst2 =
TypeConversionUtil.getSuperClassSubstitutor(
aSuper, bClass, classResolveResult2.getSubstitutor());
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(aSuper)) {
PsiType mapping1 = subst1.substitute(parameter);
PsiType mapping2 = subst2.substitute(parameter);
if (mapping1 != null && mapping2 != null) {
substitutor =
substitutor.put(
parameter,
getLeastContainingTypeArgument(
mapping1,
mapping2,
compared,
manager,
type1.equals(mapping1) && type2.equals(mapping2) ? aSuper : null,
parameter));
} else {
substitutor = substitutor.put(parameter, null);
}
}
conjuncts[i] =
JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createType(aSuper, substitutor);
}
return PsiIntersectionType.createIntersection(conjuncts);
}
if (type2 instanceof PsiArrayType && !(type1 instanceof PsiArrayType)) {
return getLeastUpperBound(type2, type1, compared, manager);
}
if (type1 instanceof PsiArrayType) {
PsiElementFactory factory =
JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
GlobalSearchScope all = GlobalSearchScope.allScope(manager.getProject());
PsiClassType serializable =
factory.createTypeByFQClassName(CommonClassNames.JAVA_IO_SERIALIZABLE, all);
PsiClassType cloneable =
factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_CLONEABLE, all);
PsiType arraySupers = PsiIntersectionType.createIntersection(serializable, cloneable);
return getLeastUpperBound(arraySupers, type2, compared, manager);
}
return PsiType.getJavaLangObject(manager, GlobalSearchScope.allScope(manager.getProject()));
}
public static PsiType getGreatestLowerBound(@Nullable PsiType type1, @Nullable PsiType type2) {
if (type1 == null || type2 == null) return null;
return PsiIntersectionType.createIntersection(type1, type2);
}
@Nullable
private PsiType getNominalTypeInner(@Nullable PsiElement resolved) {
if (resolved == null && !"class".equals(getReferenceName())) {
resolved = resolve();
}
if (resolved instanceof PsiClass) {
final PsiElementFactory factory = JavaPsiFacade.getInstance(getProject()).getElementFactory();
if (PsiUtil.isInstanceThisRef(this)) {
final PsiClassType categoryType = GdkMethodUtil.getCategoryType((PsiClass) resolved);
if (categoryType != null) {
return categoryType;
} else {
return factory.createType((PsiClass) resolved);
}
} else if (PsiUtil.isSuperReference(this)) {
PsiClass contextClass = PsiUtil.getContextClass(this);
if (GrTraitUtil.isTrait(contextClass)) {
PsiClassType[] extendsTypes = contextClass.getExtendsListTypes();
PsiClassType[] implementsTypes = contextClass.getImplementsListTypes();
PsiClassType[] superTypes =
ArrayUtil.mergeArrays(implementsTypes, extendsTypes, PsiClassType.ARRAY_FACTORY);
return PsiIntersectionType.createIntersection(ArrayUtil.reverseArray(superTypes));
}
return factory.createType((PsiClass) resolved);
}
if (getParent() instanceof GrReferenceExpression) {
return factory.createType((PsiClass) resolved);
} else {
return TypesUtil.createJavaLangClassType(
factory.createType((PsiClass) resolved), getProject(), getResolveScope());
}
}
if (resolved instanceof GrVariable) {
return ((GrVariable) resolved).getDeclaredType();
}
if (resolved instanceof PsiVariable) {
return ((PsiVariable) resolved).getType();
}
if (resolved instanceof PsiMethod) {
PsiMethod method = (PsiMethod) resolved;
if (PropertyUtil.isSimplePropertySetter(method)
&& !method.getName().equals(getReferenceName())) {
return method.getParameterList().getParameters()[0].getType();
}
// 'class' property with explicit generic
PsiClass containingClass = method.getContainingClass();
if (containingClass != null
&& CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName())
&& "getClass".equals(method.getName())) {
return TypesUtil.createJavaLangClassType(
PsiImplUtil.getQualifierType(this), getProject(), getResolveScope());
}
return PsiUtil.getSmartReturnType(method);
}
if (resolved == null) {
final PsiType fromClassRef = getTypeFromClassRef(this);
if (fromClassRef != null) {
return fromClassRef;
}
final PsiType fromMapAccess = getTypeFromMapAccess(this);
if (fromMapAccess != null) {
return fromMapAccess;
}
final PsiType fromSpreadOperator = getTypeFromSpreadOperator(this);
if (fromSpreadOperator != null) {
return fromSpreadOperator;
}
}
return null;
}
