@NotNull
public static Collection<PsiFileSystemItem> getAbsoluteTopLevelDirLocations(
final @NotNull PsiFile file) {
final VirtualFile virtualFile = file.getVirtualFile();
if (virtualFile == null) {
return Collections.emptyList();
}
final Project project = file.getProject();
PsiDirectory parent = file.getParent();
final Module module = ModuleUtil.findModuleForPsiElement(parent == null ? file : parent);
if (module == null) {
return Collections.emptyList();
}
final FileReferenceHelper[] helpers = FileReferenceHelperRegistrar.getHelpers();
final ArrayList<PsiFileSystemItem> list = new ArrayList<PsiFileSystemItem>();
for (FileReferenceHelper helper : helpers) {
if (helper.isMine(project, virtualFile)) {
final Collection<PsiFileSystemItem> roots = helper.getRoots(module);
for (PsiFileSystemItem root : roots) {
LOG.assertTrue(root != null, "Helper " + helper + " produced a null root for " + file);
}
list.addAll(roots);
}
}
if (list.size() == 0) {
list.addAll(FileReferenceHelperRegistrar.getNotNullHelper(file).getRoots(module));
}
return list;
}
@NotNull
private static List<PsiMethod> findMethodsBySignature(
@NotNull PsiClass aClass,
@NotNull PsiMethod patternMethod,
boolean checkBases,
boolean stopOnFirst) {
final PsiMethod[] methodsByName = aClass.findMethodsByName(patternMethod.getName(), checkBases);
if (methodsByName.length == 0) return Collections.emptyList();
final List<PsiMethod> methods = new SmartList<PsiMethod>();
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (final PsiMethod method : methodsByName) {
final PsiClass superClass = method.getContainingClass();
final PsiSubstitutor substitutor;
if (checkBases && !aClass.equals(superClass)) {
substitutor =
TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY);
} else {
substitutor = PsiSubstitutor.EMPTY;
}
final MethodSignature signature = method.getSignature(substitutor);
if (signature.equals(patternSignature)) {
methods.add(method);
if (stopOnFirst) {
break;
}
}
}
return methods;
}
private List<HighlightInfo> getHighlights() {
if (myReadAccessRanges.isEmpty() && myWriteAccessRanges.isEmpty()) {
return Collections.emptyList();
}
Set<Pair<Object, TextRange>> existingMarkupTooltips = new HashSet<Pair<Object, TextRange>>();
for (RangeHighlighter highlighter : myEditor.getMarkupModel().getAllHighlighters()) {
existingMarkupTooltips.add(
Pair.create(
highlighter.getErrorStripeTooltip(),
new TextRange(highlighter.getStartOffset(), highlighter.getEndOffset())));
}
List<HighlightInfo> result =
new ArrayList<HighlightInfo>(myReadAccessRanges.size() + myWriteAccessRanges.size());
for (TextRange range : myReadAccessRanges) {
ContainerUtil.addIfNotNull(
createHighlightInfo(
range, HighlightInfoType.ELEMENT_UNDER_CARET_READ, existingMarkupTooltips),
result);
}
for (TextRange range : myWriteAccessRanges) {
ContainerUtil.addIfNotNull(
createHighlightInfo(
range, HighlightInfoType.ELEMENT_UNDER_CARET_WRITE, existingMarkupTooltips),
result);
}
return result;
}
@NotNull
public Collection<PsiFileSystemItem> computeDefaultContexts() {
final PsiFile file = getContainingFile();
if (file == null) return Collections.emptyList();
if (myOptions != null) {
final Function<PsiFile, Collection<PsiFileSystemItem>> value =
DEFAULT_PATH_EVALUATOR_OPTION.getValue(myOptions);
if (value != null) {
final Collection<PsiFileSystemItem> roots = value.fun(file);
if (roots != null) {
for (PsiFileSystemItem root : roots) {
if (root == null) {
LOG.error("Default path evaluator " + value + " produced a null root for " + file);
}
}
return roots;
}
}
}
if (isAbsolutePathReference()) {
return getAbsoluteTopLevelDirLocations(file);
}
return getContextByFile(file);
}
@NotNull
private List<PsiMethod> changeReturnType(
final PsiMethod method, @NotNull final PsiType returnType) {
final PsiMethod[] methods = getChangeRoots(method, returnType);
if (methods == null) {
// canceled
return Collections.emptyList();
}
final MethodSignatureChangeVisitor methodSignatureChangeVisitor =
new MethodSignatureChangeVisitor();
for (PsiMethod targetMethod : methods) {
methodSignatureChangeVisitor.addBase(targetMethod);
ChangeSignatureProcessor processor =
new UsagesAwareChangeSignatureProcessor(
method.getProject(),
targetMethod,
false,
null,
myName,
returnType,
RemoveUnusedParameterFix.getNewParametersInfo(targetMethod, null),
methodSignatureChangeVisitor);
processor.run();
}
return methodSignatureChangeVisitor.getAffectedMethods();
}
/**
* intersection may spread over several injected fragments
*
* @param rangeToEdit range in encoded(raw) PSI
* @return list of ranges in encoded (raw) PSI
*/
@Override
@SuppressWarnings({"ConstantConditions", "unchecked"})
@NotNull
public List<TextRange> intersectWithAllEditableFragments(
@NotNull PsiFile injectedPsi, @NotNull TextRange rangeToEdit) {
Place shreds = InjectedLanguageUtil.getShreds(injectedPsi);
if (shreds == null) return Collections.emptyList();
Object result = null; // optimization: TextRange or ArrayList
int count = 0;
int offset = 0;
for (PsiLanguageInjectionHost.Shred shred : shreds) {
TextRange encodedRange =
TextRange.from(
offset + shred.getPrefix().length(), shred.getRangeInsideHost().getLength());
TextRange intersection = encodedRange.intersection(rangeToEdit);
if (intersection != null) {
count++;
if (count == 1) {
result = intersection;
} else if (count == 2) {
TextRange range = (TextRange) result;
if (range.isEmpty()) {
result = intersection;
count = 1;
} else if (intersection.isEmpty()) {
count = 1;
} else {
List<TextRange> list = new ArrayList<TextRange>();
list.add(range);
list.add(intersection);
result = list;
}
} else if (intersection.isEmpty()) {
count--;
} else {
((List<TextRange>) result).add(intersection);
}
}
offset +=
shred.getPrefix().length()
+ shred.getRangeInsideHost().getLength()
+ shred.getSuffix().length();
}
return count == 0
? Collections.<TextRange>emptyList()
: count == 1 ? Collections.singletonList((TextRange) result) : (List<TextRange>) result;
}
public static List<Match> hasDuplicates(final PsiFile file, final PsiMember member) {
final DuplicatesFinder duplicatesFinder = createDuplicatesFinder(member);
if (duplicatesFinder == null) {
return Collections.emptyList();
}
return duplicatesFinder.findDuplicates(file);
}
@Override
public void doApplyInformationToEditor() {
final boolean virtSpace =
TargetElementUtil.inVirtualSpace(myEditor, myEditor.getCaretModel().getOffset());
final List<HighlightInfo> infos =
virtSpace ? Collections.<HighlightInfo>emptyList() : getHighlights();
UpdateHighlightersUtil.setHighlightersToEditor(
myProject, myDocument, 0, myFile.getTextLength(), infos, getColorsScheme(), getId());
}
@NotNull
private Collection<DefaultMutableTreeNode> getSelectedNodes() {
if (!isValid()) {
return Collections.emptyList();
}
JTree tree = myStructureViewComponent.getTree();
if (tree == null) return Collections.emptyList();
TreePath[] selected = tree.getSelectionModel().getSelectionPaths();
if (selected == null || selected.length == 0) return Collections.emptyList();
return ContainerUtil.map(
selected,
new Function<TreePath, DefaultMutableTreeNode>() {
@Override
public DefaultMutableTreeNode fun(TreePath treePath) {
return (DefaultMutableTreeNode) treePath.getLastPathComponent();
}
});
}
private static List<PsiElement> getTopLevelRegExpChars(String regExpText, Project project) {
@SuppressWarnings("deprecation")
PsiFile file = PsiFileFactory.getInstance(project).createFileFromText("A.regexp", regExpText);
List<PsiElement> result = null;
final PsiElement[] children = file.getChildren();
for (PsiElement child : children) {
PsiElement[] grandChildren = child.getChildren();
if (grandChildren.length != 1)
return Collections
.emptyList(); // a | b, more than one branch, can not predict in current way
for (PsiElement grandGrandChild : grandChildren[0].getChildren()) {
if (result == null) result = new ArrayList<>();
result.add(grandGrandChild);
}
}
return result != null ? result : Collections.<PsiElement>emptyList();
}
@Nullable("null means DFA analysis has failed (too complex to analyze)")
public static Collection<PsiExpression> getCachedVariableValues(
@Nullable final PsiVariable variable, @Nullable final PsiElement context) {
if (variable == null || context == null) return Collections.emptyList();
CachedValue<MultiValuesMap<PsiVariable, PsiExpression>> cachedValue =
context.getUserData(DFA_VARIABLE_INFO_KEY);
if (cachedValue == null) {
final PsiElement codeBlock = DfaPsiUtil.getEnclosingCodeBlock(variable, context);
cachedValue =
CachedValuesManager.getManager(context.getProject())
.createCachedValue(
new CachedValueProvider<MultiValuesMap<PsiVariable, PsiExpression>>() {
@Override
public Result<MultiValuesMap<PsiVariable, PsiExpression>> compute() {
final MultiValuesMap<PsiVariable, PsiExpression> result;
if (codeBlock == null) {
result = null;
} else {
final ValuableInstructionVisitor visitor =
new ValuableInstructionVisitor(context);
RunnerResult runnerResult =
new ValuableDataFlowRunner().analyzeMethod(codeBlock, visitor);
if (runnerResult == RunnerResult.OK) {
result = visitor.myValues;
} else {
result = TOO_COMPLEX;
}
}
return new Result<MultiValuesMap<PsiVariable, PsiExpression>>(
result, variable);
}
},
false);
context.putUserData(DFA_VARIABLE_INFO_KEY, cachedValue);
}
final MultiValuesMap<PsiVariable, PsiExpression> value = cachedValue.getValue();
if (value == TOO_COMPLEX) return null;
final Collection<PsiExpression> expressions = value == null ? null : value.get(variable);
return expressions == null ? Collections.<PsiExpression>emptyList() : expressions;
}
@NotNull
private static Collection<PsiClass> findRelatedActivities(
@NotNull XmlFile file,
@NotNull AndroidFacet facet,
@NotNull DomFileDescription<?> description) {
if (description instanceof LayoutDomFileDescription) {
final Computable<List<GotoRelatedItem>> computable =
AndroidGotoRelatedProvider.getLazyItemsForXmlFile(file, facet);
if (computable == null) {
return Collections.emptyList();
}
final List<GotoRelatedItem> items = computable.compute();
if (items.isEmpty()) {
return Collections.emptyList();
}
final PsiClass activityClass = findActivityClass(facet.getModule());
if (activityClass == null) {
return Collections.emptyList();
}
final List<PsiClass> result = new ArrayList<PsiClass>();
for (GotoRelatedItem item : items) {
final PsiElement element = item.getElement();
if (element instanceof PsiClass) {
final PsiClass aClass = (PsiClass) element;
if (aClass.isInheritor(activityClass, true)) {
result.add(aClass);
}
}
}
return result;
} else {
return findRelatedActivitiesForMenu(file, facet);
}
}
@NotNull
public static List<Pair<Breakpoint, Event>> getEventDescriptors(
SuspendContextImpl suspendContext) {
DebuggerManagerThreadImpl.assertIsManagerThread();
if (suspendContext == null) {
return Collections.emptyList();
}
final EventSet events = suspendContext.getEventSet();
if (events == null) {
return Collections.emptyList();
}
final List<Pair<Breakpoint, Event>> eventDescriptors = new SmartList<Pair<Breakpoint, Event>>();
final RequestManagerImpl requestManager = suspendContext.getDebugProcess().getRequestsManager();
for (final Event event : events) {
final Requestor requestor = requestManager.findRequestor(event.request());
if (requestor instanceof Breakpoint) {
eventDescriptors.add(Pair.create((Breakpoint) requestor, event));
}
}
return eventDescriptors;
}
private List<PsiElement> _process(final Matcher matcher, final boolean resolve) {
final XmlTag root = matcher.getRoot();
if (root == null || myHistory.contains(root)) {
return Collections.emptyList();
}
myHistory.add(root);
final List<PsiElement> found = new ArrayList<PsiElement>();
try {
if (matcher.isRecursive()) {
root.accept(
new XmlRecursiveElementVisitor() {
@Override
public void visitXmlTag(XmlTag tag) {
final Matcher.Result match = matcher.match(tag);
if (match != null) {
if (match.chain != null) {
found.addAll(_process(match.chain, resolve));
} else {
assert match.result != null;
found.add(match.result);
if (resolve) throw Stop.DONE;
}
}
super.visitXmlTag(tag);
}
});
} else {
root.acceptChildren(
new XmlElementVisitor() {
@Override
public void visitXmlTag(XmlTag tag) {
final Matcher.Result match = matcher.match(tag);
if (match != null) {
if (match.chain != null) {
found.addAll(_process(match.chain, resolve));
} else {
assert match.result != null;
found.add(match.result);
if (resolve) throw Stop.DONE;
}
}
}
});
}
} catch (Stop e) {
/* processing stopped */
}
return found;
}
@NotNull
private static List<PsiMember> findByMap(
@NotNull PsiClass aClass, String name, boolean checkBases, @NotNull MemberType type) {
if (name == null) return Collections.emptyList();
if (checkBases) {
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allMethodsMap = getMap(aClass, type);
List<Pair<PsiMember, PsiSubstitutor>> list = allMethodsMap.get(name);
if (list == null) return Collections.emptyList();
List<PsiMember> ret = new ArrayList<PsiMember>(list.size());
for (final Pair<PsiMember, PsiSubstitutor> info : list) {
ret.add(info.getFirst());
}
return ret;
} else {
PsiMember[] members = null;
switch (type) {
case METHOD:
members = aClass.getMethods();
break;
case CLASS:
members = aClass.getInnerClasses();
break;
case FIELD:
members = aClass.getFields();
break;
}
List<PsiMember> list = new ArrayList<PsiMember>();
for (PsiMember member : members) {
if (name.equals(member.getName())) {
list.add(member);
}
}
return list;
}
}
@NotNull
private File fileToFile(PsiJavaFile javaFile, List<String> additionalImports) {
PsiImportList importList = javaFile.getImportList();
List<Import> imports =
importList == null
? Collections.<Import>emptyList()
: importsToImportList(importList.getAllImportStatements());
for (String i : additionalImports) imports.add(new Import(i));
return new File(
quoteKeywords(javaFile.getPackageName()),
imports,
classesToClassList(javaFile.getClasses()),
createMainFunction(javaFile));
}
@NotNull
public static Collection<? extends PsiElement> getPossibleInitializationElements(
final PsiElement qualifierExpression) {
if (qualifierExpression instanceof PsiMethodCallExpression) {
return Collections.singletonList(qualifierExpression);
}
if (qualifierExpression instanceof PsiReferenceExpression) {
final PsiElement targetElement = ((PsiReferenceExpression) qualifierExpression).resolve();
if (!(targetElement instanceof PsiVariable)) {
return Collections.emptyList();
}
final Collection<? extends PsiElement> variableValues =
getCachedVariableValues((PsiVariable) targetElement, qualifierExpression);
if (variableValues == null || variableValues.isEmpty()) {
return DfaPsiUtil.getVariableAssignmentsInFile(
(PsiVariable) targetElement, false, qualifierExpression);
}
return variableValues;
}
if (qualifierExpression instanceof PsiLiteralExpression) {
return Collections.singletonList(qualifierExpression);
}
return Collections.emptyList();
}
@NotNull
private List<AnnotationData> collectExternalAnnotations(@NotNull PsiModifierListOwner listOwner) {
if (!hasAnyAnnotationsRoots()) return Collections.emptyList();
List<AnnotationData> cached;
while (true) {
cached = (List<AnnotationData>) cache.get(listOwner);
if (cached == NO_DATA || !cached.isEmpty()) return cached;
List<AnnotationData> computed = doCollect(listOwner, false);
if (cache.replace(listOwner, cached, computed)) {
cached = computed;
break;
}
}
return cached;
}
public static List<PsiLambdaExpression> collectLambdas(
@NotNull SourcePosition position, final boolean onlyOnTheLine) {
ApplicationManager.getApplication().assertReadAccessAllowed();
PsiFile file = position.getFile();
final int line = position.getLine();
final Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file);
if (document == null || line >= document.getLineCount()) {
return Collections.emptyList();
}
PsiElement element = position.getElementAt();
final TextRange lineRange = DocumentUtil.getLineTextRange(document, line);
do {
PsiElement parent = element.getParent();
if (parent == null || (parent.getTextOffset() < lineRange.getStartOffset())) {
break;
}
element = parent;
} while (true);
final List<PsiLambdaExpression> lambdas = new ArrayList<PsiLambdaExpression>(3);
final PsiElementVisitor lambdaCollector =
new JavaRecursiveElementVisitor() {
@Override
public void visitLambdaExpression(PsiLambdaExpression expression) {
super.visitLambdaExpression(expression);
if (!onlyOnTheLine || getFirstElementOnTheLine(expression, document, line) != null) {
lambdas.add(expression);
}
}
};
element.accept(lambdaCollector);
// add initial lambda if we're inside already
PsiElement method = getContainingMethod(element);
if (method instanceof PsiLambdaExpression) {
lambdas.add((PsiLambdaExpression) method);
}
for (PsiElement sibling = getNextElement(element);
sibling != null;
sibling = getNextElement(sibling)) {
if (!intersects(lineRange, sibling)) {
break;
}
sibling.accept(lambdaCollector);
}
return lambdas;
}
private static Collection<String> extractAnnotationValuesFromJavaDoc(
PsiDocTag tag, String parameter) {
if (tag == null) return Collections.emptyList();
Collection<String> results = new ArrayList<>();
Matcher matcher =
Pattern.compile("\\@testng.test(?:.*)" + parameter + "\\s*=\\s*\"(.*?)\".*")
.matcher(tag.getText());
if (matcher.matches()) {
String[] groups = matcher.group(1).split("[,\\s]");
for (String group : groups) {
final String trimmed = group.trim();
if (trimmed.length() > 0) {
results.add(trimmed);
}
}
}
return results;
}
@NotNull
public static List<Pair<PsiMethod, PsiSubstitutor>> findMethodsAndTheirSubstitutorsByName(
@NotNull PsiClass psiClass, String name, boolean checkBases) {
if (!checkBases) {
final PsiMethod[] methodsByName = psiClass.findMethodsByName(name, false);
final List<Pair<PsiMethod, PsiSubstitutor>> ret =
new ArrayList<Pair<PsiMethod, PsiSubstitutor>>(methodsByName.length);
for (final PsiMethod method : methodsByName) {
ret.add(new Pair<PsiMethod, PsiSubstitutor>(method, PsiSubstitutor.EMPTY));
}
return ret;
}
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> map = getMap(psiClass, MemberType.METHOD);
@SuppressWarnings("unchecked")
List<Pair<PsiMethod, PsiSubstitutor>> list = (List) map.get(name);
return list == null
? Collections.<Pair<PsiMethod, PsiSubstitutor>>emptyList()
: Collections.unmodifiableList(list);
}
@NotNull
private Collection<PsiFileSystemItem> getContextByFile(@NotNull PsiFile file) {
final PsiElement context = file.getContext();
if (context != null) file = context.getContainingFile();
if (useIncludingFileAsContext()) {
final FileContextProvider contextProvider = FileContextProvider.getProvider(file);
if (contextProvider != null) {
final Collection<PsiFileSystemItem> folders = contextProvider.getContextFolders(file);
if (!folders.isEmpty()) {
return folders;
}
final PsiFile contextFile = contextProvider.getContextFile(file);
if (contextFile != null) {
return Collections.<PsiFileSystemItem>singleton(contextFile.getParent());
}
}
}
VirtualFile virtualFile = file.getOriginalFile().getVirtualFile();
if (virtualFile != null) {
final FileReferenceHelper[] helpers = FileReferenceHelperRegistrar.getHelpers();
final ArrayList<PsiFileSystemItem> list = new ArrayList<PsiFileSystemItem>();
final Project project = file.getProject();
for (FileReferenceHelper helper : helpers) {
if (helper.isMine(project, virtualFile)) {
list.addAll(helper.getContexts(project, virtualFile));
}
}
if (list.size() > 0) {
return list;
}
final VirtualFile parent = virtualFile.getParent();
if (parent != null) {
final PsiDirectory directory = file.getManager().findDirectory(parent);
if (directory != null) {
return Collections.<PsiFileSystemItem>singleton(directory);
}
}
}
return Collections.emptyList();
}
public ExtractClassProcessor(
PsiClass sourceClass,
List<PsiField> fields,
List<PsiMethod> methods,
List<PsiClass> innerClasses,
String newPackageName,
String newClassName) {
this(
sourceClass,
fields,
methods,
innerClasses,
newPackageName,
null,
newClassName,
null,
false,
Collections.<MemberInfo>emptyList());
}
@NotNull
public Collection<ClassDescriptor> getTopLevelObjectsByName(
@NotNull String name,
@NotNull JetSimpleNameExpression expression,
@NotNull ResolveSession resolveSession,
@NotNull GlobalSearchScope scope) {
BindingContext context = ResolveSessionUtils.resolveToExpression(resolveSession, expression);
JetScope jetScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
if (jetScope == null) {
return Collections.emptyList();
}
Set<ClassDescriptor> result = Sets.newHashSet();
Collection<JetObjectDeclaration> topObjects =
JetTopLevelShortObjectNameIndex.getInstance().get(name, project, scope);
for (JetObjectDeclaration objectDeclaration : topObjects) {
FqName fqName = JetPsiUtil.getFQName(objectDeclaration);
assert fqName != null
: "Local object declaration in JetTopLevelShortObjectNameIndex:"
+ objectDeclaration.getText();
result.addAll(
ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, fqName, true));
}
for (PsiClass psiClass :
JetFromJavaDescriptorHelper.getCompiledClassesForTopLevelObjects(
project, GlobalSearchScope.allScope(project))) {
String qualifiedName = psiClass.getQualifiedName();
if (qualifiedName != null) {
FqName fqName = new FqName(qualifiedName);
result.addAll(
ResolveSessionUtils.getClassOrObjectDescriptorsByFqName(resolveSession, fqName, true));
}
}
return result;
}
@NotNull
private List<Pair<PsiClass, VirtualFile>> doFindClasses(
@NotNull String qName, @NotNull final GlobalSearchScope scope) {
final Collection<PsiClass> classes =
JavaFullClassNameIndex.getInstance().get(qName.hashCode(), myManager.getProject(), scope);
if (classes.isEmpty()) return Collections.emptyList();
List<Pair<PsiClass, VirtualFile>> result = new ArrayList<>(classes.size());
for (PsiClass aClass : classes) {
final String qualifiedName = aClass.getQualifiedName();
if (qualifiedName == null || !qualifiedName.equals(qName)) continue;
PsiFile file = aClass.getContainingFile();
if (file == null) {
throw new AssertionError("No file for class: " + aClass + " of " + aClass.getClass());
}
final boolean valid = file.isValid();
VirtualFile vFile = file.getVirtualFile();
if (!valid) {
LOG.error(
"Invalid file "
+ file
+ "; virtualFile:"
+ vFile
+ (vFile != null && !vFile.isValid() ? " (invalid)" : "")
+ "; id="
+ (vFile == null ? 0 : ((VirtualFileWithId) vFile).getId()),
new PsiInvalidElementAccessException(aClass));
continue;
}
if (!hasAcceptablePackage(vFile)) continue;
result.add(Pair.create(aClass, vFile));
}
return result;
}
@Override
public List<AbstractStepDefinition> loadStepsFor(
@Nullable PsiFile featureFile, @NotNull Module module) {
final GlobalSearchScope dependenciesScope =
module.getModuleWithDependenciesAndLibrariesScope(true);
Collection<PsiClass> stepDefAnnotationCandidates =
JavaFullClassNameIndex.getInstance()
.get(
CUCUMBER_RUNTIME_JAVA_STEP_DEF_ANNOTATION.hashCode(),
module.getProject(),
dependenciesScope);
PsiClass stepDefAnnotationClass = null;
for (PsiClass candidate : stepDefAnnotationCandidates) {
if (CUCUMBER_RUNTIME_JAVA_STEP_DEF_ANNOTATION.equals(candidate.getQualifiedName())) {
stepDefAnnotationClass = candidate;
break;
}
}
if (stepDefAnnotationClass == null) {
return Collections.emptyList();
}
final List<AbstractStepDefinition> result = new ArrayList<AbstractStepDefinition>();
final Query<PsiClass> stepDefAnnotations =
AnnotatedElementsSearch.searchPsiClasses(stepDefAnnotationClass, dependenciesScope);
for (PsiClass annotationClass : stepDefAnnotations) {
final Query<PsiMethod> javaStepDefinitions =
AnnotatedElementsSearch.searchPsiMethods(annotationClass, dependenciesScope);
for (PsiMethod stepDefMethod : javaStepDefinitions) {
result.add(new JavaStepDefinition(stepDefMethod));
}
}
return result;
}
private List<Pair<StubBasedPsiElementBase, CompositeElement>> calcStubAstBindings(
final ASTNode root, final Document cachedDocument) {
final StubTree stubTree = derefStub();
if (stubTree == null) {
return Collections.emptyList();
}
final Iterator<StubElement<?>> stubs = stubTree.getPlainList().iterator();
stubs.next(); // Skip file stub;
final List<Pair<StubBasedPsiElementBase, CompositeElement>> result =
ContainerUtil.newArrayList();
final StubBuilder builder = ((IStubFileElementType) getContentElementType()).getBuilder();
LazyParseableElement.setSuppressEagerPsiCreation(true);
try {
((TreeElement) root)
.acceptTree(
new RecursiveTreeElementWalkingVisitor() {
@Override
protected void visitNode(TreeElement node) {
CompositeElement parent = node.getTreeParent();
if (parent != null
&& builder.skipChildProcessingWhenBuildingStubs(parent, node)) {
return;
}
IElementType type = node.getElementType();
if (type instanceof IStubElementType
&& ((IStubElementType) type).shouldCreateStub(node)) {
if (!stubs.hasNext()) {
reportStubAstMismatch(
"Stub list is less than AST, last AST element: "
+ node.getElementType()
+ " "
+ node,
stubTree,
cachedDocument);
}
final StubElement stub = stubs.next();
if (stub.getStubType() != node.getElementType()) {
reportStubAstMismatch(
"Stub and PSI element type mismatch in "
+ getName()
+ ": stub "
+ stub
+ ", AST "
+ node.getElementType()
+ "; "
+ node,
stubTree,
cachedDocument);
}
PsiElement psi = stub.getPsi();
assert psi != null
: "Stub " + stub + " (" + stub.getClass() + ") has returned null PSI";
result.add(Pair.create((StubBasedPsiElementBase) psi, (CompositeElement) node));
}
super.visitNode(node);
}
});
} finally {
LazyParseableElement.setSuppressEagerPsiCreation(false);
}
if (stubs.hasNext()) {
reportStubAstMismatch(
"Stub list in " + getName() + " has more elements than PSI", stubTree, cachedDocument);
}
return result;
}
@NotNull
public Collection<FunctionDescriptor> getTopLevelFunctionDescriptorsByName(
@NotNull String name,
@NotNull JetSimpleNameExpression expression,
@NotNull ResolveSession resolveSession,
@NotNull GlobalSearchScope scope) {
// name parameter can differ from expression.getReferenceName() when expression contains
// completion suffix
Name referenceName =
expression.getIdentifier() == null
? JetPsiUtil.getConventionName(expression)
: Name.identifier(name);
if (referenceName == null || referenceName.toString().isEmpty()) {
return Collections.emptyList();
}
BindingContext context = ResolveSessionUtils.resolveToExpression(resolveSession, expression);
JetScope jetScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
if (jetScope == null) {
return Collections.emptyList();
}
Set<FunctionDescriptor> result = Sets.newHashSet();
Collection<PsiMethod> topLevelFunctionPrototypes =
JetFromJavaDescriptorHelper.getTopLevelFunctionPrototypesByName(
referenceName.getName(), project, scope);
for (PsiMethod method : topLevelFunctionPrototypes) {
FqName functionFQN = JetFromJavaDescriptorHelper.getJetTopLevelDeclarationFQN(method);
if (functionFQN != null) {
JetImportDirective importDirective =
JetPsiFactory.createImportDirective(project, new ImportPath(functionFQN, false));
Collection<? extends DeclarationDescriptor> declarationDescriptors =
new QualifiedExpressionResolver()
.analyseImportReference(
importDirective,
jetScope,
new BindingTraceContext(),
resolveSession.getModuleConfiguration());
for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
if (declarationDescriptor instanceof FunctionDescriptor) {
result.add((FunctionDescriptor) declarationDescriptor);
}
}
}
}
Set<FqName> affectedPackages = Sets.newHashSet();
Collection<JetNamedFunction> jetNamedFunctions =
JetShortFunctionNameIndex.getInstance().get(referenceName.getName(), project, scope);
for (JetNamedFunction jetNamedFunction : jetNamedFunctions) {
PsiFile containingFile = jetNamedFunction.getContainingFile();
if (containingFile instanceof JetFile) {
JetFile jetFile = (JetFile) containingFile;
String packageName = jetFile.getPackageName();
if (packageName != null) {
affectedPackages.add(new FqName(packageName));
}
}
}
for (FqName affectedPackage : affectedPackages) {
NamespaceDescriptor packageDescriptor =
resolveSession.getPackageDescriptorByFqName(affectedPackage);
assert packageDescriptor != null
: "There's a function in stub index with invalid package: " + affectedPackage;
JetScope memberScope = packageDescriptor.getMemberScope();
result.addAll(memberScope.getFunctions(referenceName));
}
return result;
}
/** @author max Date: Oct 21, 2001 */
public class RefMethodImpl extends RefJavaElementImpl implements RefMethod {
private static final List<RefMethod> EMPTY_METHOD_LIST = Collections.emptyList();
private static final RefParameter[] EMPTY_PARAMS_ARRAY = new RefParameter[0];
private static final int IS_APPMAIN_MASK = 0x10000;
private static final int IS_LIBRARY_OVERRIDE_MASK = 0x20000;
private static final int IS_CONSTRUCTOR_MASK = 0x40000;
private static final int IS_ABSTRACT_MASK = 0x80000;
private static final int IS_BODY_EMPTY_MASK = 0x100000;
private static final int IS_ONLY_CALLS_SUPER_MASK = 0x200000;
private static final int IS_RETURN_VALUE_USED_MASK = 0x400000;
private static final int IS_TEST_METHOD_MASK = 0x4000000;
private static final int IS_CALLED_ON_SUBCLASS_MASK = 0x8000000;
private static final String RETURN_VALUE_UNDEFINED = "#";
private List<RefMethod> mySuperMethods;
private List<RefMethod> myDerivedMethods;
private List<String> myUnThrownExceptions;
private RefParameter[] myParameters;
private String myReturnValueTemplate;
protected final RefClass myOwnerClass;
RefMethodImpl(@NotNull RefClass ownerClass, PsiMethod method, RefManager manager) {
super(method, manager);
((RefClassImpl) ownerClass).add(this);
myOwnerClass = ownerClass;
}
// To be used only from RefImplicitConstructor.
protected RefMethodImpl(@NotNull String name, @NotNull RefClass ownerClass) {
super(name, ownerClass);
myOwnerClass = ownerClass;
((RefClassImpl) ownerClass).add(this);
addOutReference(getOwnerClass());
((RefClassImpl) getOwnerClass()).addInReference(this);
setConstructor(true);
}
@Override
public void add(@NotNull RefEntity child) {
if (child instanceof RefParameter) {
return;
}
super.add(child);
}
@Override
public List<RefEntity> getChildren() {
List<RefEntity> superChildren = super.getChildren();
if (myParameters == null) return superChildren;
if (superChildren == null || superChildren.isEmpty())
return Arrays.<RefEntity>asList(myParameters);
List<RefEntity> allChildren =
new ArrayList<RefEntity>(superChildren.size() + myParameters.length);
allChildren.addAll(superChildren);
Collections.addAll(allChildren, myParameters);
return allChildren;
}
@Override
protected void initialize() {
final PsiMethod method = (PsiMethod) getElement();
LOG.assertTrue(method != null);
setConstructor(method.isConstructor());
final PsiType returnType = method.getReturnType();
setFlag(
returnType == null
|| PsiType.VOID.equals(returnType)
|| returnType.equalsToText(CommonClassNames.JAVA_LANG_VOID),
IS_RETURN_VALUE_USED_MASK);
if (!isReturnValueUsed()) {
myReturnValueTemplate = RETURN_VALUE_UNDEFINED;
}
if (isConstructor()) {
addReference(getOwnerClass(), getOwnerClass().getElement(), method, false, true, null);
}
if (getOwnerClass().isInterface()) {
setAbstract(false);
} else {
setAbstract(method.hasModifierProperty(PsiModifier.ABSTRACT));
}
setAppMain(isAppMain(method, this));
setLibraryOverride(method.hasModifierProperty(PsiModifier.NATIVE));
initializeSuperMethods(method);
if (isExternalOverride()) {
((RefClassImpl) getOwnerClass()).addLibraryOverrideMethod(this);
}
@NonNls final String name = method.getName();
if (getOwnerClass().isTestCase() && name.startsWith("test")) {
setTestMethod(true);
}
PsiParameter[] paramList = method.getParameterList().getParameters();
if (paramList.length > 0) {
myParameters = new RefParameterImpl[paramList.length];
for (int i = 0; i < paramList.length; i++) {
PsiParameter parameter = paramList[i];
myParameters[i] = getRefJavaManager().getParameterReference(parameter, i);
}
}
if (method.hasModifierProperty(PsiModifier.NATIVE)) {
updateReturnValueTemplate(null);
updateThrowsList(null);
}
collectUncaughtExceptions(method);
}
private static boolean isAppMain(PsiMethod psiMethod, RefMethod refMethod) {
if (!refMethod.isStatic()) return false;
if (!PsiType.VOID.equals(psiMethod.getReturnType())) return false;
PsiMethod appMainPattern = ((RefMethodImpl) refMethod).getRefJavaManager().getAppMainPattern();
if (MethodSignatureUtil.areSignaturesEqual(psiMethod, appMainPattern)) return true;
PsiMethod appPremainPattern =
((RefMethodImpl) refMethod).getRefJavaManager().getAppPremainPattern();
if (MethodSignatureUtil.areSignaturesEqual(psiMethod, appPremainPattern)) return true;
PsiMethod appAgentmainPattern =
((RefMethodImpl) refMethod).getRefJavaManager().getAppAgentmainPattern();
return MethodSignatureUtil.areSignaturesEqual(psiMethod, appAgentmainPattern);
}
private void checkForSuperCall(PsiMethod method) {
if (isConstructor()) {
PsiCodeBlock body = method.getBody();
if (body == null) return;
PsiStatement[] statements = body.getStatements();
boolean isBaseExplicitlyCalled = false;
if (statements.length > 0) {
PsiStatement first = statements[0];
if (first instanceof PsiExpressionStatement) {
PsiExpression firstExpression = ((PsiExpressionStatement) first).getExpression();
if (firstExpression instanceof PsiMethodCallExpression) {
PsiExpression qualifierExpression =
((PsiMethodCallExpression) firstExpression)
.getMethodExpression()
.getQualifierExpression();
if (qualifierExpression instanceof PsiReferenceExpression) {
@NonNls String text = qualifierExpression.getText();
if ("super".equals(text) || text.equals("this")) {
isBaseExplicitlyCalled = true;
}
}
}
}
}
if (!isBaseExplicitlyCalled) {
for (RefClass superClass : getOwnerClass().getBaseClasses()) {
RefMethodImpl superDefaultConstructor =
(RefMethodImpl) superClass.getDefaultConstructor();
if (superDefaultConstructor != null) {
superDefaultConstructor.addInReference(this);
addOutReference(superDefaultConstructor);
}
}
}
}
}
@Override
@NotNull
public Collection<RefMethod> getSuperMethods() {
if (mySuperMethods == null) return EMPTY_METHOD_LIST;
if (mySuperMethods.size() > 10) {
LOG.info("method: " + getName() + " owner:" + getOwnerClass().getQualifiedName());
}
if (getRefManager().isOfflineView()) {
LOG.debug("Should not traverse graph offline");
}
return mySuperMethods;
}
@Override
@NotNull
public Collection<RefMethod> getDerivedMethods() {
if (myDerivedMethods == null) return EMPTY_METHOD_LIST;
return myDerivedMethods;
}
@Override
public boolean isBodyEmpty() {
return checkFlag(IS_BODY_EMPTY_MASK);
}
@Override
public boolean isOnlyCallsSuper() {
return checkFlag(IS_ONLY_CALLS_SUPER_MASK);
}
@Override
public boolean hasBody() {
return !isAbstract() && !getOwnerClass().isInterface() || !isBodyEmpty();
}
private void initializeSuperMethods(PsiMethod method) {
if (getRefManager().isOfflineView()) return;
for (PsiMethod psiSuperMethod : method.findSuperMethods()) {
if (getRefManager().belongsToScope(psiSuperMethod)) {
RefMethodImpl refSuperMethod = (RefMethodImpl) getRefManager().getReference(psiSuperMethod);
if (refSuperMethod != null) {
addSuperMethod(refSuperMethod);
refSuperMethod.markExtended(this);
}
} else {
setLibraryOverride(true);
}
}
}
public void addSuperMethod(RefMethodImpl refSuperMethod) {
if (!getSuperMethods().contains(refSuperMethod)
&& !refSuperMethod.getSuperMethods().contains(this)) {
if (mySuperMethods == null) {
mySuperMethods = new ArrayList<RefMethod>(1);
}
mySuperMethods.add(refSuperMethod);
}
}
public void markExtended(RefMethodImpl method) {
if (!getDerivedMethods().contains(method) && !method.getDerivedMethods().contains(this)) {
if (myDerivedMethods == null) {
myDerivedMethods = new ArrayList<RefMethod>(1);
}
myDerivedMethods.add(method);
}
}
@Override
@NotNull
public RefParameter[] getParameters() {
if (myParameters == null) return EMPTY_PARAMS_ARRAY;
return myParameters;
}
@Override
public void buildReferences() {
// Work on code block to find what we're referencing...
PsiMethod method = (PsiMethod) getElement();
if (method == null) return;
PsiCodeBlock body = method.getBody();
final RefJavaUtil refUtil = RefJavaUtil.getInstance();
refUtil.addReferences(method, this, body);
refUtil.addReferences(method, this, method.getModifierList());
checkForSuperCall(method);
setOnlyCallsSuper(refUtil.isMethodOnlyCallsSuper(method));
setBodyEmpty(
isOnlyCallsSuper()
|| !isExternalOverride() && (body == null || body.getStatements().length == 0));
refUtil.addTypeReference(method, method.getReturnType(), getRefManager(), this);
for (RefParameter parameter : getParameters()) {
refUtil.setIsFinal(parameter, parameter.getElement().hasModifierProperty(PsiModifier.FINAL));
}
getRefManager().fireBuildReferences(this);
}
private void collectUncaughtExceptions(@NotNull PsiMethod method) {
if (isExternalOverride()) return;
if (getRefManager().isOfflineView()) return;
@NonNls final String name = method.getName();
if (getOwnerClass().isTestCase() && name.startsWith("test")) return;
if (getSuperMethods().isEmpty()) {
PsiClassType[] throwsList = method.getThrowsList().getReferencedTypes();
if (throwsList.length > 0) {
myUnThrownExceptions =
throwsList.length == 1
? new SmartList<String>()
: new ArrayList<String>(throwsList.length);
for (final PsiClassType type : throwsList) {
PsiClass aClass = type.resolve();
String fqn = aClass == null ? null : aClass.getQualifiedName();
if (fqn != null) {
myUnThrownExceptions.add(fqn);
}
}
}
}
final PsiCodeBlock body = method.getBody();
if (body == null) return;
final Collection<PsiClassType> exceptionTypes =
ExceptionUtil.collectUnhandledExceptions(body, method, false);
for (final PsiClassType exceptionType : exceptionTypes) {
updateThrowsList(exceptionType);
}
}
public void removeUnThrownExceptions(PsiClass unThrownException) {
if (myUnThrownExceptions != null) {
myUnThrownExceptions.remove(unThrownException.getQualifiedName());
}
}
@Override
public void accept(@NotNull final RefVisitor visitor) {
if (visitor instanceof RefJavaVisitor) {
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
((RefJavaVisitor) visitor).visitMethod(RefMethodImpl.this);
}
});
} else {
super.accept(visitor);
}
}
@Override
public boolean isExternalOverride() {
return isLibraryOverride(new HashSet<RefMethod>());
}
private boolean isLibraryOverride(@NotNull Collection<RefMethod> processed) {
if (!processed.add(this)) return false;
if (checkFlag(IS_LIBRARY_OVERRIDE_MASK)) return true;
for (RefMethod superMethod : getSuperMethods()) {
if (((RefMethodImpl) superMethod).isLibraryOverride(processed)) {
setFlag(true, IS_LIBRARY_OVERRIDE_MASK);
return true;
}
}
return false;
}
@Override
public boolean isAppMain() {
return checkFlag(IS_APPMAIN_MASK);
}
@Override
public boolean isAbstract() {
return checkFlag(IS_ABSTRACT_MASK);
}
@Override
public boolean hasSuperMethods() {
return !getSuperMethods().isEmpty() || isExternalOverride();
}
@Override
public boolean isReferenced() {
// Directly called from somewhere..
for (RefElement refCaller : getInReferences()) {
if (!getDerivedMethods().contains(refCaller)) return true;
}
// Library override probably called from library code.
return isExternalOverride();
}
@Override
public boolean hasSuspiciousCallers() {
// Directly called from somewhere..
for (RefElement refCaller : getInReferences()) {
if (((RefElementImpl) refCaller).isSuspicious() && !getDerivedMethods().contains(refCaller))
return true;
}
// Library override probably called from library code.
if (isExternalOverride()) return true;
// Class isn't instantiated. Most probably we have problem with class, not method.
if (!isStatic() && !isConstructor()) {
if (((RefClassImpl) getOwnerClass()).isSuspicious()) return true;
// Is an override. Probably called via reference to base class.
for (RefMethod refSuper : getSuperMethods()) {
if (((RefMethodImpl) refSuper).isSuspicious()) return true;
}
}
return false;
}
@Override
public boolean isConstructor() {
return checkFlag(IS_CONSTRUCTOR_MASK);
}
@Override
public RefClass getOwnerClass() {
return (RefClass) getOwner();
}
@NotNull
@Override
public String getName() {
if (isValid()) {
final String[] result = new String[1];
final Runnable runnable =
new Runnable() {
@Override
public void run() {
PsiMethod psiMethod = (PsiMethod) getElement();
if (psiMethod instanceof SyntheticElement) {
result[0] = psiMethod.getName();
} else {
result[0] =
PsiFormatUtil.formatMethod(
psiMethod,
PsiSubstitutor.EMPTY,
PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS,
PsiFormatUtilBase.SHOW_TYPE);
}
}
};
ApplicationManager.getApplication().runReadAction(runnable);
return result[0];
} else {
return super.getName();
}
}
@Override
public String getExternalName() {
final String[] result = new String[1];
final Runnable runnable =
new Runnable() {
@Override
public void run() {
final PsiMethod psiMethod = (PsiMethod) getElement();
LOG.assertTrue(psiMethod != null);
result[0] = PsiFormatUtil.getExternalName(psiMethod, true, Integer.MAX_VALUE);
}
};
ApplicationManager.getApplication().runReadAction(runnable);
return result[0];
}
@Nullable
public static RefMethod methodFromExternalName(RefManager manager, String externalName) {
return (RefMethod)
manager.getReference(
findPsiMethod(PsiManager.getInstance(manager.getProject()), externalName));
}
@Nullable
public static PsiMethod findPsiMethod(PsiManager manager, String externalName) {
final int spaceIdx = externalName.indexOf(' ');
final String className = externalName.substring(0, spaceIdx);
final PsiClass psiClass = ClassUtil.findPsiClass(manager, className);
if (psiClass == null) return null;
try {
PsiElementFactory factory =
JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory();
String methodSignature = externalName.substring(spaceIdx + 1);
PsiMethod patternMethod = factory.createMethodFromText(methodSignature, psiClass);
return psiClass.findMethodBySignature(patternMethod, false);
} catch (IncorrectOperationException e) {
// Do nothing. Returning null is acceptable in this case.
return null;
}
}
@Override
public void referenceRemoved() {
if (getOwnerClass() != null) {
((RefClassImpl) getOwnerClass()).methodRemoved(this);
}
super.referenceRemoved();
for (RefMethod superMethod : getSuperMethods()) {
superMethod.getDerivedMethods().remove(this);
}
for (RefMethod subMethod : getDerivedMethods()) {
subMethod.getSuperMethods().remove(this);
}
ArrayList<RefElement> deletedRefs = new ArrayList<RefElement>();
for (RefParameter parameter : getParameters()) {
getRefManager().removeRefElement(parameter, deletedRefs);
}
}
@Override
public boolean isSuspicious() {
if (isConstructor()
&& PsiModifier.PRIVATE.equals(getAccessModifier())
&& getParameters().length == 0
&& getOwnerClass().getConstructors().size() == 1) return false;
return super.isSuspicious();
}
public void setReturnValueUsed(boolean value) {
if (checkFlag(IS_RETURN_VALUE_USED_MASK) == value) return;
setFlag(value, IS_RETURN_VALUE_USED_MASK);
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).setReturnValueUsed(value);
}
}
@Override
public boolean isReturnValueUsed() {
return checkFlag(IS_RETURN_VALUE_USED_MASK);
}
public void updateReturnValueTemplate(PsiExpression expression) {
if (myReturnValueTemplate == null) return;
if (!getSuperMethods().isEmpty()) {
for (final RefMethod refMethod : getSuperMethods()) {
RefMethodImpl refSuper = (RefMethodImpl) refMethod;
refSuper.updateReturnValueTemplate(expression);
}
} else {
String newTemplate = null;
final RefJavaUtil refUtil = RefJavaUtil.getInstance();
if (expression instanceof PsiLiteralExpression) {
PsiLiteralExpression psiLiteralExpression = (PsiLiteralExpression) expression;
newTemplate = psiLiteralExpression.getText();
} else if (expression instanceof PsiReferenceExpression) {
PsiReferenceExpression referenceExpression = (PsiReferenceExpression) expression;
PsiElement resolved = referenceExpression.resolve();
if (resolved instanceof PsiField) {
PsiField psiField = (PsiField) resolved;
if (psiField.hasModifierProperty(PsiModifier.STATIC)
&& psiField.hasModifierProperty(PsiModifier.FINAL)
&& refUtil.compareAccess(refUtil.getAccessModifier(psiField), getAccessModifier())
>= 0) {
newTemplate =
PsiFormatUtil.formatVariable(
psiField,
PsiFormatUtilBase.SHOW_NAME
| PsiFormatUtilBase.SHOW_CONTAINING_CLASS
| PsiFormatUtilBase.SHOW_FQ_NAME,
PsiSubstitutor.EMPTY);
}
}
} else if (refUtil.isCallToSuperMethod(expression, (PsiMethod) getElement())) return;
//noinspection StringEquality
if (myReturnValueTemplate == RETURN_VALUE_UNDEFINED) {
myReturnValueTemplate = newTemplate;
} else if (!Comparing.equal(myReturnValueTemplate, newTemplate)) {
myReturnValueTemplate = null;
}
}
}
public void updateParameterValues(PsiExpression[] args) {
if (isExternalOverride()) return;
if (!getSuperMethods().isEmpty()) {
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).updateParameterValues(args);
}
} else {
final RefParameter[] params = getParameters();
if (params.length <= args.length && params.length > 0) {
for (int i = 0; i < args.length; i++) {
RefParameter refParameter;
if (params.length <= i) {
refParameter = params[params.length - 1];
} else {
refParameter = params[i];
}
((RefParameterImpl) refParameter).updateTemplateValue(args[i]);
}
}
}
}
@Override
public String getReturnValueIfSame() {
//noinspection StringEquality
if (myReturnValueTemplate == RETURN_VALUE_UNDEFINED) return null;
return myReturnValueTemplate;
}
public void updateThrowsList(PsiClassType exceptionType) {
if (!getSuperMethods().isEmpty()) {
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).updateThrowsList(exceptionType);
}
} else if (myUnThrownExceptions != null) {
if (exceptionType == null) {
myUnThrownExceptions = null;
return;
}
PsiClass exceptionClass = exceptionType.resolve();
JavaPsiFacade facade = JavaPsiFacade.getInstance(myManager.getProject());
for (int i = myUnThrownExceptions.size() - 1; i >= 0; i--) {
String exceptionFqn = myUnThrownExceptions.get(i);
PsiClass classType =
facade.findClass(
exceptionFqn, GlobalSearchScope.allScope(getRefManager().getProject()));
if (InheritanceUtil.isInheritorOrSelf(exceptionClass, classType, true)
|| InheritanceUtil.isInheritorOrSelf(classType, exceptionClass, true)) {
myUnThrownExceptions.remove(i);
}
}
if (myUnThrownExceptions.isEmpty()) myUnThrownExceptions = null;
}
}
@Override
@Nullable
public PsiClass[] getUnThrownExceptions() {
if (getRefManager().isOfflineView()) {
LOG.debug("Should not traverse graph offline");
}
if (myUnThrownExceptions == null) return null;
JavaPsiFacade facade = JavaPsiFacade.getInstance(myManager.getProject());
List<PsiClass> result = new ArrayList<PsiClass>(myUnThrownExceptions.size());
for (String exception : myUnThrownExceptions) {
PsiClass element =
facade.findClass(exception, GlobalSearchScope.allScope(myManager.getProject()));
if (element != null) result.add(element);
}
return result.toArray(new PsiClass[result.size()]);
}
public void setLibraryOverride(boolean libraryOverride) {
setFlag(libraryOverride, IS_LIBRARY_OVERRIDE_MASK);
}
private void setAppMain(boolean appMain) {
setFlag(appMain, IS_APPMAIN_MASK);
}
private void setAbstract(boolean anAbstract) {
setFlag(anAbstract, IS_ABSTRACT_MASK);
}
public void setBodyEmpty(boolean bodyEmpty) {
setFlag(bodyEmpty, IS_BODY_EMPTY_MASK);
}
private void setOnlyCallsSuper(boolean onlyCallsSuper) {
setFlag(onlyCallsSuper, IS_ONLY_CALLS_SUPER_MASK);
}
private void setConstructor(boolean constructor) {
setFlag(constructor, IS_CONSTRUCTOR_MASK);
}
@Override
public boolean isTestMethod() {
return checkFlag(IS_TEST_METHOD_MASK);
}
private void setTestMethod(boolean testMethod) {
setFlag(testMethod, IS_TEST_METHOD_MASK);
}
@Override
public PsiModifierListOwner getElement() {
return (PsiModifierListOwner) super.getElement();
}
@Override
public boolean isCalledOnSubClass() {
return checkFlag(IS_CALLED_ON_SUBCLASS_MASK);
}
public void setCalledOnSubClass(boolean isCalledOnSubClass) {
setFlag(isCalledOnSubClass, IS_CALLED_ON_SUBCLASS_MASK);
}
}
@NotNull
private List<GroovyResolveResult> getInapplicableResults() {
if (myInapplicable == null) return Collections.emptyList();
return myInapplicable;
}
