@Override
@Nullable
public PsiPackage findPackage(@NotNull String packageName) {
Query<VirtualFile> dirs = myPackageIndex.getDirsByPackageName(packageName, true);
if (dirs.findFirst() == null) return null;
return new PsiPackageImpl(myManager, packageName);
}
private static boolean isFixApplicable(PsiExpression location) {
// conservative check to see if the result value of the postfix
// expression is used later in the same expression statement.
// Applying the quick fix in such a case would break the code
// because the explicit unboxing code would split the expression in
// multiple statements.
final PsiElement parent = location.getParent();
if (!(parent instanceof PsiPostfixExpression)) {
return true;
}
final PsiReferenceExpression reference;
if (location instanceof PsiReferenceExpression) {
reference = (PsiReferenceExpression) location;
} else if (location instanceof PsiArrayAccessExpression) {
final PsiArrayAccessExpression arrayAccessExpression = (PsiArrayAccessExpression) location;
final PsiExpression expression = arrayAccessExpression.getArrayExpression();
if (!(expression instanceof PsiReferenceExpression)) {
return true;
}
reference = (PsiReferenceExpression) expression;
} else {
return true;
}
final PsiElement element = reference.resolve();
if (element == null) {
return true;
}
final PsiStatement statement = PsiTreeUtil.getParentOfType(parent, PsiStatement.class);
final LocalSearchScope scope = new LocalSearchScope(statement);
final Query<PsiReference> query = ReferencesSearch.search(element, scope);
final Collection<PsiReference> references = query.findAll();
return references.size() <= 1;
}
@Override
public void visitReferenceExpression(PsiReferenceExpression expression) {
if (argumentsContainCatchParameter || !visited.add(expression)) {
return;
}
super.visitReferenceExpression(expression);
final PsiElement target = expression.resolve();
if (!parameter.equals(target)) {
if (target instanceof PsiLocalVariable) {
final PsiLocalVariable variable = (PsiLocalVariable) target;
final Query<PsiReference> query =
ReferencesSearch.search(variable, variable.getUseScope(), false);
query.forEach(
reference -> {
final PsiElement element = reference.getElement();
final PsiElement parent =
PsiTreeUtil.skipParentsOfType(element, PsiParenthesizedExpression.class);
if (!(parent instanceof PsiReferenceExpression)) {
return true;
}
final PsiElement grandParent = parent.getParent();
if (!(grandParent instanceof PsiMethodCallExpression)) {
return true;
}
final PsiMethodCallExpression methodCallExpression =
(PsiMethodCallExpression) grandParent;
final PsiExpressionList argumentList = methodCallExpression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
for (PsiExpression argument : arguments) {
argument.accept(ReferenceFinder.this);
}
return true;
});
final PsiExpression initializer = variable.getInitializer();
if (initializer != null) {
initializer.accept(this);
}
}
return;
}
if (ignoreGetMessage) {
argumentsContainCatchParameter = true;
} else {
final PsiElement parent = expression.getParent();
if (parent instanceof PsiReferenceExpression) {
final PsiElement grandParent = parent.getParent();
if (grandParent instanceof PsiMethodCallExpression) {
return;
}
}
argumentsContainCatchParameter = true;
}
}
private static boolean hasDirectoriesInScope(
Query<VirtualFile> dirs, final GlobalSearchScope scope) {
CommonProcessors.FindProcessor<VirtualFile> findProcessor =
new CommonProcessors.FindProcessor<VirtualFile>() {
@Override
protected boolean accept(VirtualFile file) {
return scope.accept(file);
}
};
dirs.forEach(findProcessor);
return findProcessor.isFound();
}
@Override
public void visitClass(@NotNull PsiClass aClass) {
// no call to super, so that it doesn't drill down to inner classes
if (aClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
return;
}
if (!UtilityClassUtil.isUtilityClass(aClass)) {
return;
}
if (ignoreClassesWithOnlyMain && hasOnlyMain(aClass)) {
return;
}
if (hasPrivateConstructor(aClass)) {
return;
}
final SearchScope scope = GlobalSearchScope.projectScope(aClass.getProject());
final Query<PsiClass> query = ClassInheritorsSearch.search(aClass, scope, true, true);
final PsiClass subclass = query.findFirst();
if (subclass != null) {
return;
}
registerClassError(aClass, aClass);
}
public static void processSubTypes(
PsiType psiType,
final PsiElement context,
boolean getRawSubtypes,
@NotNull final PrefixMatcher matcher,
Consumer<PsiType> consumer) {
int arrayDim = psiType.getArrayDimensions();
psiType = psiType.getDeepComponentType();
if (!(psiType instanceof PsiClassType)) return;
final Condition<String> shortNameCondition =
new Condition<String>() {
@Override
public boolean value(String s) {
return matcher.prefixMatches(s);
}
};
final PsiClassType baseType = (PsiClassType) psiType;
final PsiClassType.ClassResolveResult baseResult =
ApplicationManager.getApplication()
.runReadAction(
new Computable<PsiClassType.ClassResolveResult>() {
@Override
public PsiClassType.ClassResolveResult compute() {
return JavaCompletionUtil.originalize(baseType).resolveGenerics();
}
});
final PsiClass baseClass = baseResult.getElement();
final PsiSubstitutor baseSubstitutor = baseResult.getSubstitutor();
if (baseClass == null) return;
final GlobalSearchScope scope =
ApplicationManager.getApplication()
.runReadAction(
new Computable<GlobalSearchScope>() {
@Override
public GlobalSearchScope compute() {
return context.getResolveScope();
}
});
final Processor<PsiClass> inheritorsProcessor =
createInheritorsProcessor(
context, baseType, arrayDim, getRawSubtypes, consumer, baseClass, baseSubstitutor);
if (matcher.getPrefix().length() > 2) {
AllClassesGetter.processJavaClasses(
matcher,
context.getProject(),
scope,
new Processor<PsiClass>() {
@Override
public boolean process(PsiClass psiClass) {
if (psiClass.isInheritor(baseClass, true)) {
return inheritorsProcessor.process(psiClass);
}
return true;
}
});
} else {
final Query<PsiClass> baseQuery =
ClassInheritorsSearch.search(
new ClassInheritorsSearch.SearchParameters(
baseClass, scope, true, false, false, shortNameCondition));
final Query<PsiClass> query =
new FilteredQuery<PsiClass>(
baseQuery,
new Condition<PsiClass>() {
@Override
public boolean value(final PsiClass psiClass) {
return !(psiClass instanceof PsiTypeParameter);
}
});
query.forEach(inheritorsProcessor);
}
}
@Override
public void doFix(Project project, ProblemDescriptor descriptor)
throws IncorrectOperationException {
final PsiReferenceExpression parameterReference =
(PsiReferenceExpression) descriptor.getPsiElement();
final PsiElement target = parameterReference.resolve();
if (!(target instanceof PsiParameter)) {
return;
}
final PsiParameter parameter = (PsiParameter) target;
final PsiElement declarationScope = parameter.getDeclarationScope();
final PsiElement body;
if (declarationScope instanceof PsiMethod) {
final PsiMethod method = (PsiMethod) declarationScope;
body = method.getBody();
} else if (declarationScope instanceof PsiCatchSection) {
final PsiCatchSection catchSection = (PsiCatchSection) declarationScope;
body = catchSection.getCatchBlock();
} else if (declarationScope instanceof PsiLoopStatement) {
final PsiLoopStatement forStatement = (PsiLoopStatement) declarationScope;
final PsiStatement forBody = forStatement.getBody();
if (forBody instanceof PsiBlockStatement) {
final PsiBlockStatement blockStatement = (PsiBlockStatement) forBody;
body = blockStatement.getCodeBlock();
} else {
body = forBody;
}
} else {
return;
}
if (body == null) {
return;
}
final CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project);
final String parameterName = parameterReference.getText();
final JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project);
final String variableName =
javaCodeStyleManager.suggestUniqueVariableName(parameterName, parameterReference, true);
final SearchScope scope = parameter.getUseScope();
final Query<PsiReference> search = ReferencesSearch.search(parameter, scope);
final PsiReference reference = search.findFirst();
if (reference == null) {
return;
}
final PsiElement element = reference.getElement();
if (!(element instanceof PsiReferenceExpression)) {
return;
}
final PsiReferenceExpression firstReference = (PsiReferenceExpression) element;
final PsiElement[] children = body.getChildren();
final int startIndex;
final int endIndex;
if (body instanceof PsiCodeBlock) {
startIndex = 1;
endIndex = children.length - 1;
} else {
startIndex = 0;
endIndex = children.length;
}
boolean newDeclarationCreated = false;
final StringBuilder buffer = new StringBuilder();
for (int i = startIndex; i < endIndex; i++) {
final PsiElement child = children[i];
newDeclarationCreated |=
replaceVariableName(child, firstReference, variableName, parameterName, buffer);
}
final String replacementText;
if (newDeclarationCreated) {
replacementText = "{" + buffer + '}';
} else {
final PsiType type = parameterReference.getType();
if (type == null) {
return;
}
final String className = type.getCanonicalText();
replacementText =
'{' + className + ' ' + variableName + " = " + parameterName + ';' + buffer + '}';
}
final PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory();
final PsiCodeBlock block = elementFactory.createCodeBlockFromText(replacementText, null);
body.replace(block);
codeStyleManager.reformat(declarationScope);
}
public void runQuery() {
query.forEach(processor);
}
