protected boolean preprocessUsages(Ref<UsageInfo[]> refUsages) {
final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
checkExistingMethods(conflicts, true);
checkExistingMethods(conflicts, false);
final Collection<PsiClass> classes = ClassInheritorsSearch.search(myClass).findAll();
for (FieldDescriptor fieldDescriptor : myFieldDescriptors) {
final Set<PsiMethod> setters = new HashSet<PsiMethod>();
final Set<PsiMethod> getters = new HashSet<PsiMethod>();
for (PsiClass aClass : classes) {
final PsiMethod getterOverrider =
myDescriptor.isToEncapsulateGet()
? aClass.findMethodBySignature(fieldDescriptor.getGetterPrototype(), false)
: null;
if (getterOverrider != null) {
getters.add(getterOverrider);
}
final PsiMethod setterOverrider =
myDescriptor.isToEncapsulateSet()
? aClass.findMethodBySignature(fieldDescriptor.getSetterPrototype(), false)
: null;
if (setterOverrider != null) {
setters.add(setterOverrider);
}
}
if (!getters.isEmpty() || !setters.isEmpty()) {
final PsiField field = fieldDescriptor.getField();
for (PsiReference reference : ReferencesSearch.search(field)) {
final PsiElement place = reference.getElement();
if (place instanceof PsiReferenceExpression) {
final PsiExpression qualifierExpression =
((PsiReferenceExpression) place).getQualifierExpression();
final PsiClass ancestor;
if (qualifierExpression == null) {
ancestor = PsiTreeUtil.getParentOfType(place, PsiClass.class, false);
} else {
ancestor = PsiUtil.resolveClassInType(qualifierExpression.getType());
}
final boolean isGetter = !PsiUtil.isAccessedForWriting((PsiExpression) place);
for (PsiMethod overridden : isGetter ? getters : setters) {
if (InheritanceUtil.isInheritorOrSelf(myClass, ancestor, true)) {
conflicts.putValue(
overridden,
"There is already a "
+ RefactoringUIUtil.getDescription(overridden, true)
+ " which would hide generated "
+ (isGetter ? "getter" : "setter")
+ " for "
+ place.getText());
break;
}
}
}
}
}
}
return showConflicts(conflicts, refUsages.get());
}
public static PsiMethod generateSetterPrototype(
PsiField field, final PsiClass containingClass, boolean returnSelf) {
Project project = field.getProject();
JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(project);
PsiElementFactory factory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory();
String name = field.getName();
boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
VariableKind kind = codeStyleManager.getVariableKind(field);
String propertyName = codeStyleManager.variableNameToPropertyName(name, kind);
String setName = suggestSetterName(project, field);
try {
PsiMethod setMethod =
factory.createMethod(
setName, returnSelf ? factory.createType(containingClass) : PsiType.VOID);
String parameterName =
codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER);
PsiParameter param = factory.createParameter(parameterName, field.getType());
annotateWithNullableStuff(field, factory, param);
setMethod.getParameterList().add(param);
PsiUtil.setModifierProperty(setMethod, PsiModifier.PUBLIC, true);
PsiUtil.setModifierProperty(setMethod, PsiModifier.STATIC, isStatic);
@NonNls StringBuffer buffer = new StringBuffer();
buffer.append("{\n");
if (name.equals(parameterName)) {
if (!isStatic) {
buffer.append("this.");
} else {
String className = containingClass.getName();
if (className != null) {
buffer.append(className);
buffer.append(".");
}
}
}
buffer.append(name);
buffer.append("=");
buffer.append(parameterName);
buffer.append(";\n");
if (returnSelf) {
buffer.append("return this;\n");
}
buffer.append("}");
PsiCodeBlock body = factory.createCodeBlockFromText(buffer.toString(), null);
setMethod.getBody().replace(body);
setMethod = (PsiMethod) CodeStyleManager.getInstance(project).reformat(setMethod);
return setMethod;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private static void putInMap(
PsiClass aClass,
Map<MethodSignature, HierarchicalMethodSignature> result,
Map<MethodSignature, HierarchicalMethodSignatureImpl> map,
HierarchicalMethodSignature hierarchicalMethodSignature,
MethodSignature signature) {
if (!PsiUtil.isAccessible(
aClass.getProject(), hierarchicalMethodSignature.getMethod(), aClass, aClass)) return;
HierarchicalMethodSignatureImpl existing = map.get(signature);
if (existing == null) {
HierarchicalMethodSignatureImpl copy = copy(hierarchicalMethodSignature);
LOG.assertTrue(copy.getMethod().isValid());
map.put(signature, copy);
} else if (isReturnTypeIsMoreSpecificThan(hierarchicalMethodSignature, existing)
&& isSuperMethod(aClass, hierarchicalMethodSignature, existing)) {
HierarchicalMethodSignatureImpl newSuper = copy(hierarchicalMethodSignature);
mergeSupers(newSuper, existing);
LOG.assertTrue(newSuper.getMethod().isValid());
map.put(signature, newSuper);
} else if (isSuperMethod(aClass, existing, hierarchicalMethodSignature)) {
mergeSupers(existing, hierarchicalMethodSignature);
}
// just drop an invalid method declaration there - to highlight accordingly
else if (!result.containsKey(signature)) {
LOG.assertTrue(hierarchicalMethodSignature.getMethod().isValid());
result.put(signature, hierarchicalMethodSignature);
}
}
private static PsiSubstitutor obtainFinalSubstitutor(
PsiClass superClass,
PsiSubstitutor superSubstitutor,
PsiSubstitutor derivedSubstitutor,
boolean inRawContext) {
if (inRawContext) {
Set<PsiTypeParameter> typeParams = superSubstitutor.getSubstitutionMap().keySet();
PsiElementFactory factory = JavaPsiFacade.getElementFactory(superClass.getProject());
superSubstitutor =
factory.createRawSubstitutor(
derivedSubstitutor, typeParams.toArray(new PsiTypeParameter[typeParams.size()]));
}
Map<PsiTypeParameter, PsiType> map = null;
for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(superClass)) {
PsiType type = superSubstitutor.substitute(typeParameter);
final PsiType t = derivedSubstitutor.substitute(type);
if (map == null) {
map = new THashMap<PsiTypeParameter, PsiType>();
}
map.put(typeParameter, t);
}
return map == null
? PsiSubstitutor.EMPTY
: JavaPsiFacade.getInstance(superClass.getProject())
.getElementFactory()
.createSubstitutor(map);
}
private static void addDefaultConstructor(
JavaChangeInfo changeInfo, PsiClass aClass, final UsageInfo[] usages)
throws IncorrectOperationException {
if (!(aClass instanceof PsiAnonymousClass)) {
PsiElementFactory factory = JavaPsiFacade.getElementFactory(aClass.getProject());
PsiMethod defaultConstructor =
factory.createMethodFromText(aClass.getName() + "(){}", aClass);
defaultConstructor =
(PsiMethod)
CodeStyleManager.getInstance(aClass.getProject()).reformat(defaultConstructor);
defaultConstructor = (PsiMethod) aClass.add(defaultConstructor);
PsiUtil.setModifierProperty(
defaultConstructor, VisibilityUtil.getVisibilityModifier(aClass.getModifierList()), true);
addSuperCall(changeInfo, defaultConstructor, null, usages);
} else {
final PsiElement parent = aClass.getParent();
if (parent instanceof PsiNewExpression) {
final PsiExpressionList argumentList = ((PsiNewExpression) parent).getArgumentList();
final PsiClass baseClass = changeInfo.getMethod().getContainingClass();
final PsiSubstitutor substitutor =
TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY);
fixActualArgumentsList(argumentList, changeInfo, true, substitutor);
}
}
}
@NotNull
private GroovyResolveResult[] doPolyResolve(boolean incompleteCode, boolean genericsMatter) {
String name = getReferenceName();
if (name == null) return GroovyResolveResult.EMPTY_ARRAY;
if (incompleteCode) {
ResolverProcessor processor = CompletionProcessor.createRefSameNameProcessor(this, name);
new GrReferenceResolveRunner(this).resolveImpl(processor);
GroovyResolveResult[] propertyCandidates = processor.getCandidates();
if (propertyCandidates.length > 0 && !PsiUtil.isSingleBindingVariant(propertyCandidates))
return propertyCandidates;
}
try {
ResolveProfiler.start();
switch (getKind()) {
case METHOD_OR_PROPERTY:
return resolveMethodOrProperty(false, null, genericsMatter);
case TYPE_OR_PROPERTY:
return resolveTypeOrProperty();
case METHOD_OR_PROPERTY_OR_TYPE:
GroovyResolveResult[] results = resolveMethodOrProperty(false, null, genericsMatter);
if (results.length == 0) results = resolveTypeOrProperty();
return results;
default:
return GroovyResolveResult.EMPTY_ARRAY;
}
} finally {
final long time = ResolveProfiler.finish();
ResolveProfiler.write("ref", this, time);
}
}
private static boolean isGoodExpression(
PsiExpression expression,
@NotNull AllowedValues allowedValues,
@NotNull PsiElement scope,
@NotNull PsiManager manager) {
expression = PsiUtil.deparenthesizeExpression(expression);
if (expression == null) return true;
if (expression instanceof PsiConditionalExpression) {
PsiExpression thenExpression = ((PsiConditionalExpression) expression).getThenExpression();
boolean thenAllowed =
thenExpression == null || isAllowed(scope, thenExpression, allowedValues, manager);
if (!thenAllowed) return false;
PsiExpression elseExpression = ((PsiConditionalExpression) expression).getElseExpression();
return elseExpression == null || isAllowed(scope, elseExpression, allowedValues, manager);
}
if (isOneOf(expression, allowedValues, manager)) return true;
if (allowedValues.canBeOred) {
PsiExpression zero = getLiteralExpression(expression, manager, "0");
if (same(expression, zero, manager)) return true;
PsiExpression mOne = getLiteralExpression(expression, manager, "-1");
if (same(expression, mOne, manager)) return true;
if (expression instanceof PsiPolyadicExpression) {
IElementType tokenType = ((PsiPolyadicExpression) expression).getOperationTokenType();
if (JavaTokenType.OR.equals(tokenType) || JavaTokenType.AND.equals(tokenType)) {
for (PsiExpression operand : ((PsiPolyadicExpression) expression).getOperands()) {
if (!isAllowed(scope, operand, allowedValues, manager)) return false;
}
return true;
}
}
if (expression instanceof PsiPrefixExpression
&& JavaTokenType.TILDE.equals(
((PsiPrefixExpression) expression).getOperationTokenType())) {
PsiExpression operand = ((PsiPrefixExpression) expression).getOperand();
return operand == null || isAllowed(scope, operand, allowedValues, manager);
}
}
PsiElement resolved = null;
if (expression instanceof PsiReference) {
resolved = ((PsiReference) expression).resolve();
} else if (expression instanceof PsiCallExpression) {
resolved = ((PsiCallExpression) expression).resolveMethod();
}
AllowedValues allowedForRef;
if (resolved instanceof PsiModifierListOwner
&& (allowedForRef =
getAllowedValues(
(PsiModifierListOwner) resolved,
getType((PsiModifierListOwner) resolved),
null))
!= null
&& allowedForRef.isSubsetOf(allowedValues, manager)) return true;
return PsiType.NULL.equals(expression.getType());
}
private static boolean canHaveSiblingSuper(PsiMethod method, PsiClass containingClass) {
return containingClass != null
&& PsiUtil.canBeOverriden(method)
&& !method.hasModifierProperty(PsiModifier.ABSTRACT)
&& !method.hasModifierProperty(PsiModifier.NATIVE)
&& method.hasModifierProperty(PsiModifier.PUBLIC)
&& !containingClass.isInterface()
&& !CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName());
}
private static CompoundInitialState createState(InferenceSession topLevelSession) {
final PsiSubstitutor topInferenceSubstitutor =
replaceVariables(topLevelSession.getInferenceVariables());
final Map<PsiElement, InitialInferenceState> nestedStates =
new LinkedHashMap<PsiElement, InitialInferenceState>();
final InferenceSessionContainer copy =
new InferenceSessionContainer() {
@Override
public PsiSubstitutor findNestedSubstitutor(
PsiElement arg, @Nullable PsiSubstitutor defaultSession) {
// for the case foo(bar(a -> m())): top level inference won't touch lambda "a -> m()"
// for the case foo(a -> bar(b -> m())): top level inference would go till nested lambda
// "b -> m()" and the state from top level could be found here by "bar(b -> m())"
// but proceeding with additional constraints from saved point would produce new
// expression constraints with different inference variables (could be found in
// myNestedSessions)
// which won't be found in the system if we won't reject stored sessions in such cases
final PsiSubstitutor substitutor = super.findNestedSubstitutor(arg, null);
if (substitutor != null) {
return substitutor;
}
final InitialInferenceState state =
nestedStates.get(PsiTreeUtil.getParentOfType(arg, PsiCall.class));
if (state != null) {
return state.getInferenceSubstitutor();
}
return super.findNestedSubstitutor(arg, defaultSession);
}
};
final Map<PsiElement, InferenceSession> nestedSessions =
topLevelSession.getInferenceSessionContainer().myNestedSessions;
for (Map.Entry<PsiElement, InferenceSession> entry : nestedSessions.entrySet()) {
nestedStates.put(
entry.getKey(),
entry
.getValue()
.createInitialState(
copy, topLevelSession.getInferenceVariables(), topInferenceSubstitutor));
}
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
for (InferenceVariable variable : topLevelSession.getInferenceVariables()) {
final PsiType instantiation = variable.getInstantiation();
if (instantiation != PsiType.NULL) {
final PsiClass psiClass =
PsiUtil.resolveClassInClassTypeOnly(topInferenceSubstitutor.substitute(variable));
if (psiClass instanceof InferenceVariable) {
substitutor = substitutor.put((PsiTypeParameter) psiClass, instantiation);
}
}
}
return new CompoundInitialState(substitutor, nestedStates);
}
public static void setNewFieldVisibility(PsiField field, EncapsulateFieldsDescriptor descriptor) {
try {
if (descriptor.getFieldsVisibility() != null) {
field.normalizeDeclaration();
PsiUtil.setModifierProperty(field, descriptor.getFieldsVisibility(), true);
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
private static void checkExpression(
PsiExpression expression, PsiModifierListOwner owner, PsiType type, ProblemsHolder holder) {
AllowedValues allowed = getAllowedValues(owner, type, null);
if (allowed == null) return;
PsiElement scope = PsiUtil.getTopLevelEnclosingCodeBlock(expression, null);
if (scope == null) scope = expression;
if (!isAllowed(scope, expression, allowed, expression.getManager())) {
registerProblem(expression, allowed, holder);
}
}
private static PsiType doFun(GrReferenceExpression refExpr) {
if (ResolveUtil.isClassReference(refExpr)) {
GrExpression qualifier = refExpr.getQualifier();
LOG.assertTrue(qualifier != null);
return TypesUtil.createJavaLangClassType(
qualifier.getType(), refExpr.getProject(), refExpr.getResolveScope());
}
if (PsiUtil.isCompileStatic(refExpr)) {
final GroovyResolveResult resolveResult = refExpr.advancedResolve();
final PsiElement resolvedF = resolveResult.getElement();
final PsiType type;
if (resolvedF instanceof GrField) {
type = ((GrField) resolvedF).getType();
} else if (resolvedF instanceof GrAccessorMethod) {
type = ((GrAccessorMethod) resolvedF).getProperty().getType();
} else {
type = null;
}
if (type != null) {
return resolveResult.getSubstitutor().substitute(type);
}
}
final PsiElement resolved = refExpr.resolve();
final PsiType nominal = refExpr.getNominalType();
Boolean reassigned = GrReassignedLocalVarsChecker.isReassignedVar(refExpr);
if (reassigned != null && reassigned.booleanValue()) {
return GrReassignedLocalVarsChecker.getReassignedVarType(refExpr, true);
}
final PsiType inferred = getInferredTypes(refExpr, resolved);
if (inferred == null) {
if (nominal == null) {
// inside nested closure we could still try to infer from variable initializer. Not sound,
// but makes sense
if (resolved instanceof GrVariable) {
LOG.assertTrue(resolved.isValid());
return ((GrVariable) resolved).getTypeGroovy();
}
}
return nominal;
}
if (nominal == null) return inferred;
if (!TypeConversionUtil.isAssignable(TypeConversionUtil.erasure(nominal), inferred, false)) {
if (resolved instanceof GrVariable
&& ((GrVariable) resolved).getTypeElementGroovy() != null) {
return nominal;
}
}
return inferred;
}
public static boolean processDeclarationsInClass(
@NotNull PsiClass aClass,
@NotNull final PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw) {
if (last instanceof PsiTypeParameterList || last instanceof PsiModifierList) {
return true; // TypeParameterList and ModifierList do not see our declarations
}
if (visited != null && visited.contains(aClass)) return true;
PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY);
isRaw = isRaw || PsiUtil.isRawSubstitutor(aClass, substitutor);
ParameterizedCachedValue<MembersMap, PsiClass> cache =
getValues(aClass); // aClass.getUserData(MAP_IN_CLASS_KEY);
boolean upToDate = cache.hasUpToDateValue();
LanguageLevel languageLevel = PsiUtil.getLanguageLevel(place);
if (
/*true || */ upToDate) {
final NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
String name = nameHint.getName(state);
return processCachedMembersByName(
aClass,
processor,
state,
visited,
last,
place,
isRaw,
substitutor,
cache.getValue(aClass),
name,
languageLevel);
}
}
return processDeclarationsInClassNotCached(
aClass, processor, state, visited, last, place, isRaw, languageLevel);
}
@Override
public boolean processDeclarations(
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
PsiElement lastParent,
@NotNull PsiElement place) {
GlobalSearchScope scope = place.getResolveScope();
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this);
ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
final JavaPsiFacade facade = getFacade();
final Condition<String> prefixMatcher = processor.getHint(JavaCompletionHints.NAME_FILTER);
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
final String shortName = nameHint.getName(state);
if (containsClassNamed(shortName)
&& processClassesByName(processor, state, scope, shortName)) return false;
} else if (prefixMatcher != null) {
for (String className : getClassNamesCache()) {
if (prefixMatcher.value(className)) {
if (processClassesByName(processor, state, scope, className)) return false;
}
}
} else {
PsiClass[] classes = getClasses(scope);
if (!processClasses(processor, state, classes)) return false;
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.PACKAGE)) {
NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
PsiPackage aPackage = findSubPackageByName(nameHint.getName(state));
if (aPackage != null) {
if (!processor.execute(aPackage, state)) return false;
}
} else {
PsiPackage[] packs = getSubPackages(scope);
for (PsiPackage pack : packs) {
final String packageName = pack.getName();
if (packageName == null) continue;
if (!facade.getNameHelper().isIdentifier(packageName, PsiUtil.getLanguageLevel(this))) {
continue;
}
if (!processor.execute(pack, state)) {
return false;
}
}
}
}
return true;
}
public static boolean dependsOnTypeParams(
PsiType type,
PsiType functionalInterfaceType,
PsiElement lambdaExpression,
PsiTypeParameter... param2Check) {
return depends(
type,
new TypeParamsChecker(
lambdaExpression, PsiUtil.resolveClassInType(functionalInterfaceType)),
param2Check);
}
private static boolean shouldMarkRed(@NotNull Object object, @NotNull PsiElement place) {
if (!(object instanceof PsiMember)) return false;
if (Java15APIUsageInspectionBase.isForbiddenApiUsage(
(PsiMember) object, PsiUtil.getLanguageLevel(place))) return true;
if (object instanceof PsiEnumConstant) {
return findConstantsUsedInSwitch(place)
.contains(CompletionUtil.getOriginalOrSelf((PsiEnumConstant) object));
}
return false;
}
@Override
public boolean processDeclarations(
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
PsiElement lastParent,
@NotNull PsiElement place) {
GlobalSearchScope scope = place.getResolveScope();
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this);
ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
final Condition<String> nameCondition = processor.getHint(JavaCompletionHints.NAME_FILTER);
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
final String shortName = nameHint.getName(state);
final PsiClass[] classes = findClassByShortName(shortName, scope);
if (!processClasses(processor, state, classes, Conditions.<String>alwaysTrue()))
return false;
} else {
PsiClass[] classes = getClasses(scope);
if (!processClasses(
processor,
state,
classes,
nameCondition != null ? nameCondition : Conditions.<String>alwaysTrue())) return false;
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.PACKAGE)) {
NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
PsiPackage aPackage = findSubPackageByName(nameHint.getName(state));
if (aPackage != null) {
if (!processor.execute(aPackage, state)) return false;
}
} else {
PsiPackage[] packs = getSubPackages(scope);
for (PsiPackage pack : packs) {
final String packageName = pack.getName();
if (packageName == null) continue;
if (!PsiNameHelper.getInstance(myManager.getProject())
.isIdentifier(packageName, PsiUtil.getLanguageLevel(this))) {
continue;
}
if (!processor.execute(pack, state)) {
return false;
}
}
}
}
return true;
}
@Override
public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
final GroovyResolveResult result = advancedResolve();
if (result.isInvokedOnProperty()) {
final String name = GroovyPropertyUtils.getPropertyNameByAccessorName(newElementName);
if (name != null) {
newElementName = name;
}
}
if (PsiUtil.isThisOrSuperRef(this)) return this;
return handleElementRenameSimple(newElementName);
}
public static boolean nameCanBeImported(@NotNull String fqName, @NotNull PsiElement context) {
final PsiClass containingClass = PsiTreeUtil.getParentOfType(context, PsiClass.class);
if (containingClass != null) {
if (fqName.equals(containingClass.getQualifiedName())) {
return true;
}
final String shortName = ClassUtil.extractClassName(fqName);
final PsiClass[] innerClasses = containingClass.getAllInnerClasses();
for (PsiClass innerClass : innerClasses) {
if (innerClass.hasModifierProperty(PsiModifier.PRIVATE)) {
continue;
}
if (innerClass.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) {
if (!ClassUtils.inSamePackage(innerClass, containingClass)) {
continue;
}
}
final String className = innerClass.getName();
if (shortName.equals(className)) {
return false;
}
}
PsiField field = containingClass.findFieldByName(shortName, false);
if (field != null) {
return false;
}
field = containingClass.findFieldByName(shortName, true);
if (field != null
&& PsiUtil.isAccessible(containingClass.getProject(), field, containingClass, null)) {
return false;
}
}
final PsiJavaFile file = PsiTreeUtil.getParentOfType(context, PsiJavaFile.class);
if (file == null) {
return false;
}
if (hasExactImportConflict(fqName, file)) {
return false;
}
if (hasOnDemandImportConflict(fqName, file, true)) {
return false;
}
if (containsConflictingReference(file, fqName)) {
return false;
}
if (containsConflictingClass(fqName, file)) {
return false;
}
return !containsConflictingClassName(fqName, file);
}
public static PsiMethod generateGetterPrototype(PsiField field) {
PsiElementFactory factory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory();
Project project = field.getProject();
String name = field.getName();
String getName = suggestGetterName(project, field);
try {
PsiMethod getMethod = factory.createMethod(getName, field.getType());
PsiUtil.setModifierProperty(getMethod, PsiModifier.PUBLIC, true);
if (field.hasModifierProperty(PsiModifier.STATIC)) {
PsiUtil.setModifierProperty(getMethod, PsiModifier.STATIC, true);
}
annotateWithNullableStuff(field, factory, getMethod);
PsiCodeBlock body = factory.createCodeBlockFromText("{\nreturn " + name + ";\n}", null);
getMethod.getBody().replace(body);
getMethod = (PsiMethod) CodeStyleManager.getInstance(project).reformat(getMethod);
return getMethod;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
public static PsiClass getProviderClass(final PsiElement element, final PsiClass topLevelClass) {
final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(element, PsiAnnotation.class);
if (annotation != null) {
final PsiAnnotationMemberValue value =
annotation.findDeclaredAttributeValue("dataProviderClass");
if (value instanceof PsiClassObjectAccessExpression) {
final PsiTypeElement operand = ((PsiClassObjectAccessExpression) value).getOperand();
final PsiClass psiClass = PsiUtil.resolveClassInType(operand.getType());
if (psiClass != null) {
return psiClass;
}
}
}
return topLevelClass;
}
private void suggestNamesForCollectionInheritors(
final PsiType type,
final VariableKind variableKind,
final Collection<String> suggestions,
final boolean correctKeywords) {
PsiType componentType = PsiUtil.extractIterableTypeParameter(type, false);
if (componentType == null || componentType.equals(type)) {
return;
}
String typeName = normalizeTypeName(getTypeName(componentType));
if (typeName != null) {
ContainerUtil.addAll(
suggestions, getSuggestionsByName(typeName, variableKind, true, correctKeywords));
}
}
@Nullable
public static PsiType getFunctionalInterfaceReturnType(
@Nullable PsiType functionalInterfaceType) {
final PsiClassType.ClassResolveResult resolveResult =
PsiUtil.resolveGenericsClassInType(functionalInterfaceType);
final PsiClass psiClass = resolveResult.getElement();
if (psiClass != null) {
final MethodSignature methodSignature = getFunction(psiClass);
if (methodSignature != null) {
final PsiType returnType = getReturnType(psiClass, methodSignature);
return resolveResult.getSubstitutor().substitute(returnType);
}
}
return null;
}
// uses hierarchy signature tree if available, traverses class structure by itself otherwise
public static boolean processDirectSuperMethodsSmart(
@NotNull PsiMethod method, @NotNull Processor<PsiMethod> superMethodProcessor) {
// boolean old = PsiSuperMethodUtil.isSuperMethod(method, superMethod);
PsiClass aClass = method.getContainingClass();
if (aClass == null) return false;
if (!canHaveSuperMethod(method, true, false)) return false;
Map<MethodSignature, HierarchicalMethodSignature> cachedMap =
SIGNATURES_KEY.getCachedValueOrNull(aClass);
if (cachedMap != null) {
HierarchicalMethodSignature signature =
cachedMap.get(method.getSignature(PsiSubstitutor.EMPTY));
if (signature != null) {
List<HierarchicalMethodSignature> superSignatures = signature.getSuperSignatures();
for (HierarchicalMethodSignature superSignature : superSignatures) {
if (!superMethodProcessor.process(superSignature.getMethod())) return false;
}
return true;
}
}
PsiClassType[] directSupers = aClass.getSuperTypes();
for (PsiClassType directSuper : directSupers) {
PsiClassType.ClassResolveResult resolveResult = directSuper.resolveGenerics();
if (resolveResult.getSubstitutor() != PsiSubstitutor.EMPTY) {
// generics
break;
}
PsiClass directSuperClass = resolveResult.getElement();
if (directSuperClass == null) continue;
PsiMethod[] candidates = directSuperClass.findMethodsBySignature(method, false);
for (PsiMethod candidate : candidates) {
if (PsiUtil.canBeOverriden(candidate)) {
if (!superMethodProcessor.process(candidate)) return false;
}
}
return true;
}
List<HierarchicalMethodSignature> superSignatures =
method.getHierarchicalMethodSignature().getSuperSignatures();
for (HierarchicalMethodSignature superSignature : superSignatures) {
if (!superMethodProcessor.process(superSignature.getMethod())) return false;
}
return true;
}
public static boolean hasAccessibleConstructor(PsiType type) {
if (type instanceof PsiArrayType) return true;
final PsiClass psiClass = PsiUtil.resolveClassInType(type);
if (psiClass == null || psiClass.isEnum() || psiClass.isAnnotationType()) return false;
if (!(psiClass instanceof PsiCompiledElement)) return true;
final PsiMethod[] methods = psiClass.getConstructors();
if (methods.length == 0) return true;
for (final PsiMethod method : methods) {
if (!method.hasModifierProperty(PsiModifier.PRIVATE)) return true;
}
return false;
}
public static PsiSubstitutor obtainFinalSubstitutor(
@NotNull PsiClass candidateClass,
@NotNull PsiSubstitutor candidateSubstitutor,
@NotNull PsiClass aClass,
@NotNull PsiSubstitutor substitutor,
@NotNull PsiElementFactory elementFactory,
@NotNull LanguageLevel languageLevel) {
if (PsiUtil.isRawSubstitutor(aClass, substitutor)) {
return elementFactory.createRawSubstitutor(candidateClass);
}
final PsiType containingType =
elementFactory.createType(candidateClass, candidateSubstitutor, languageLevel);
PsiType type = substitutor.substitute(containingType);
if (!(type instanceof PsiClassType)) return candidateSubstitutor;
return ((PsiClassType) type).resolveGenerics().getSubstitutor();
}
@Override
public PsiElement handleElementRenameSimple(String newElementName)
throws IncorrectOperationException {
if (!PsiUtil.isValidReferenceName(newElementName)) {
final PsiElement old = getReferenceNameElement();
if (old == null) throw new IncorrectOperationException("ref has no name element");
PsiElement element =
GroovyPsiElementFactory.getInstance(getProject())
.createStringLiteralForReference(newElementName);
old.replace(element);
return this;
}
return super.handleElementRenameSimple(newElementName);
}
@NotNull
private MethodResolverProcessor createMethodProcessor(
boolean allVariants,
@Nullable String name,
final boolean byShape,
@Nullable GrExpression upToArgument) {
final PsiType[] argTypes = PsiUtil.getArgumentTypes(this, false, upToArgument, byShape);
if (byShape && argTypes != null) {
for (int i = 0; i < argTypes.length; i++) {
argTypes[i] = TypeConversionUtil.erasure(argTypes[i]);
}
}
PsiType qualifierType = PsiImplUtil.getQualifierType(this);
return new MethodResolverProcessor(
name, this, false, qualifierType, argTypes, getTypeArguments(), allVariants, byShape);
}
@Override
public String suggestUniqueVariableName(String baseName, PsiElement place, boolean lookForward) {
int index = 0;
PsiElement scope =
PsiTreeUtil.getNonStrictParentOfType(
place, PsiStatement.class, PsiCodeBlock.class, PsiMethod.class);
NextName:
while (true) {
String name = baseName;
if (index > 0) {
name += index;
}
index++;
if (PsiUtil.isVariableNameUnique(name, place)) {
if (lookForward) {
final String name1 = name;
PsiElement run = scope;
while (run != null) {
class CancelException extends RuntimeException {}
try {
run.accept(
new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitAnonymousClass(final PsiAnonymousClass aClass) {}
@Override
public void visitVariable(PsiVariable variable) {
if (name1.equals(variable.getName())) {
throw new CancelException();
}
}
});
} catch (CancelException e) {
continue NextName;
}
run = run.getNextSibling();
if (scope instanceof PsiMethod) { // do not check next member for param name conflict
break;
}
}
}
return name;
}
}
}
private static void checkCall(
@NotNull PsiCallExpression methodCall, @NotNull ProblemsHolder holder) {
PsiMethod method = methodCall.resolveMethod();
if (method == null) return;
PsiParameter[] parameters = method.getParameterList().getParameters();
PsiExpression[] arguments = methodCall.getArgumentList().getExpressions();
for (int i = 0; i < parameters.length; i++) {
PsiParameter parameter = parameters[i];
AllowedValues values = getAllowedValues(parameter, parameter.getType(), null);
if (values == null) continue;
if (i >= arguments.length) break;
PsiExpression argument = arguments[i];
argument = PsiUtil.deparenthesizeExpression(argument);
if (argument == null) continue;
checkMagicParameterArgument(parameter, argument, values, holder);
}
}