Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
292,900
|
void (@NotNull String name) { this.name = name; }
|
setName
|
292,901
|
List<MatchResult> () { return Collections.unmodifiableList(myChildren); }
|
getChildren
|
292,902
|
int () { if (!myMultipleMatch) return (getMatch() != null) ? 1 : 0; return myChildren.size(); }
|
size
|
292,903
|
boolean () { return myScopeMatch; }
|
isScopeMatch
|
292,904
|
boolean () { return myMultipleMatch; }
|
isMultipleMatch
|
292,905
|
boolean () { return !myChildren.isEmpty(); }
|
hasChildren
|
292,906
|
void () { myChildren.clear(); }
|
removeChildren
|
292,907
|
MatchResult () { return myChildren.remove(myChildren.size() - 1); }
|
removeLastChild
|
292,908
|
void (final boolean scopeMatch) { myScopeMatch = scopeMatch; }
|
setScopeMatch
|
292,909
|
void (final boolean multipleMatch) { myMultipleMatch = multipleMatch; }
|
setMultipleMatch
|
292,910
|
MatchResultImpl (@NotNull String name) { // @todo this could be performance bottleneck, replace with hash lookup! for (final MatchResult match : myChildren) { final MatchResultImpl res = (MatchResultImpl)match; if (name.equals(res.getName())) { return res; } } return null; }
|
getChild
|
292,911
|
MatchResult (@NotNull String name) { for (MatchResult child : myChildren) { if (name.equals(child.getName())) { return child; } final MatchResult deep = ((MatchResultImpl)child).findChild(name); if (deep != null) { return deep; } } return null; }
|
findChild
|
292,912
|
MatchResult (@NotNull String typedVar) { // @todo this could be performance bottleneck, replace with hash lookup! for (int i = 0, size = myChildren.size(); i < size; i++) { final MatchResult child = myChildren.get(i); if (typedVar.equals(child.getName())) { myChildren.remove(i); return child; } } return null; }
|
removeChild
|
292,913
|
void (@NotNull MatchResult result) { if (result instanceof MatchResultImpl) { ((MatchResultImpl)result).parent = this; } myChildren.add(result); }
|
addChild
|
292,914
|
MatchResult () { if (parent == null) return this; MatchResultImpl root = parent; while (root.parent != null) { root = root.parent; } return root; }
|
getRoot
|
292,915
|
void (@NotNull String matchImage) { this.matchImage = matchImage; }
|
setMatchImage
|
292,916
|
boolean () { return target; }
|
isTarget
|
292,917
|
void (boolean target) { this.target = target; }
|
setTarget
|
292,918
|
int () { return start; }
|
getStart
|
292,919
|
void (int start) { this.start = start; }
|
setStart
|
292,920
|
int () { return end; }
|
getEnd
|
292,921
|
void (int end) { this.end = end; }
|
setEnd
|
292,922
|
String () { return "MatchResultImpl{name='" + name + '\'' + ", matchImage='" + matchImage + '\'' + "}"; }
|
toString
|
292,923
|
void (@NotNull PsiElement element) { targetNode = element; }
|
setTargetNode
|
292,924
|
PsiElement () { return targetNode; }
|
getTargetNode
|
292,925
|
MatchingStrategy () { return strategy; }
|
getStrategy
|
292,926
|
void (MatchingStrategy strategy) { this.strategy = strategy; }
|
setStrategy
|
292,927
|
int () { return nodeCount; }
|
getNodeCount
|
292,928
|
NodeIterator () { return nodes; }
|
getNodes
|
292,929
|
void (@NotNull List<? extends PsiElement> elements) { nodes = new ArrayBackedNodeIterator(PsiUtilCore.toPsiElementArray(elements)); nodeCount = elements.size(); }
|
setNodes
|
292,930
|
boolean (final PsiElement element) { return element != null && isTypedVar(element.getText()); }
|
isTypedVar
|
292,931
|
boolean (PsiElement element) { if (element == null || element.getTextLength() <= 0) { return false; } final String str = getTypedVarString(element); return !str.isEmpty() && isTypedVar(str); }
|
isRealTypedVar
|
292,932
|
String (@NotNull PsiElement element) { final StructuralSearchProfile profile = StructuralSearchUtil.getProfileByPsiElement(element); final String typedVarString = profile == null ? element.getText() : profile.getTypedVarString(element); return typedVarString.trim(); }
|
getTypedVarString
|
292,933
|
MatchingHandler (@NotNull PsiElement node) { return handlers.get(node); }
|
getHandlerSimple
|
292,934
|
MatchingHandler (@NotNull PsiElement node) { if (node == last) { return lastHandler; } MatchingHandler handler = handlers.get(node); if (handler == null) { handler = new SimpleHandler(); setHandler(node, handler); } last = node; lastHandler = handler; return handler; }
|
getHandler
|
292,935
|
MatchingHandler (@NotNull String name) { return handlers.get(name); }
|
getHandler
|
292,936
|
void (@NotNull PsiElement node, @NotNull MatchingHandler handler) { last = null; handlers.put(node, handler); }
|
setHandler
|
292,937
|
SubstitutionHandler (@NotNull String name, @NotNull String compiledName, boolean target, int minOccurs, int maxOccurs, boolean greedy) { SubstitutionHandler handler = (SubstitutionHandler)handlers.get(compiledName); if (handler != null) return handler; handler = doCreateSubstitutionHandler(name, target, minOccurs, maxOccurs, greedy); handlers.put(compiledName, handler); return handler; }
|
createSubstitutionHandler
|
292,938
|
SubstitutionHandler (@NotNull String name, boolean target, int minOccurs, int maxOccurs, boolean greedy) { return new SubstitutionHandler(name, target, minOccurs, maxOccurs, greedy); }
|
doCreateSubstitutionHandler
|
292,939
|
SearchScope () { return scope; }
|
getScope
|
292,940
|
void (SearchScope scope) { this.scope = scope; }
|
setScope
|
292,941
|
void () { handlers.clear(); last = null; lastHandler = null; }
|
clearHandlers
|
292,942
|
boolean (@NotNull PsiElement element) { return true; }
|
isToResetHandler
|
292,943
|
List<PsiElement> (@NotNull String name) { final Collection<PsiElement> elements = variableNodes.get(name); return elements instanceof List ? (List<PsiElement>)elements : new SmartList<>(elements); }
|
getVariableNodes
|
292,944
|
void (@NotNull String name, @NotNull PsiElement node) { variableNodes.putValue(name, node); }
|
putVariableNode
|
292,945
|
PsiElement () { return myElement; }
|
getElement
|
292,946
|
boolean () { return myResult; }
|
getResult
|
292,947
|
boolean (boolean result) { return myResult = result; }
|
setResult
|
292,948
|
MatchContext () { return matchContext; }
|
getMatchContext
|
292,949
|
boolean (@NotNull NodeIterator elements, @NotNull NodeIterator elements2) { return MatchingHandler.matchInAnyOrder(elements, elements2, matchContext); }
|
doMatchInAnyOrder
|
292,950
|
boolean (@Nullable PsiElement patternNode, @Nullable PsiElement matchNode) { if (patternNode == null) { return isLeftLooseMatching(); } final MatchingHandler handler = matchContext.getPattern().getHandler(patternNode); return matchNode != null ? handler.match(patternNode, matchNode, matchContext) && handler.validate(matchContext, 1) : handler.validate(matchContext, 0); }
|
matchOptionally
|
292,951
|
NodeFilter () { return LexicalNodesFilter.getInstance(); }
|
getNodeFilter
|
292,952
|
boolean (PsiElement typedElement, PsiElement match) { final MatchingHandler initialHandler = matchContext.getPattern().getHandler(typedElement); MatchingHandler handler = initialHandler; if (handler instanceof DelegatingHandler) { handler = ((DelegatingHandler)handler).getDelegate(); } assert handler instanceof SubstitutionHandler : typedElement + " has handler " + (handler != null ? handler.getClass() : "null" + ' ' + initialHandler.getClass()); return ((SubstitutionHandler)handler).handle(match, matchContext); }
|
handleTypedElement
|
292,953
|
boolean (PsiElement element) { final MatchingHandler handler = getMatchContext().getPattern().getHandler(element); return handler instanceof SubstitutionHandler && ((SubstitutionHandler)handler).getMinOccurs() == 0; }
|
allowsAbsenceOfMatch
|
292,954
|
boolean (PsiElement patternElement, PsiElement matchElement) { ProgressManager.checkCanceled(); if (patternElement == matchElement) return true; if (patternElement == null) { // absence of pattern element is match return true; } if (matchElement == null) { // absence of match element needs check if allowed. return allowsAbsenceOfMatch(patternElement); } // copy changed data to local stack final PsiElement prevElement = myElement; myElement = matchElement; try { final PsiElementVisitor visitor = getVisitorForElement(patternElement); if (visitor != null) { patternElement.accept(visitor); } } catch (ClassCastException ex) { myResult = false; } finally { myElement = prevElement; } return myResult; }
|
match
|
292,955
|
PsiElementVisitor (PsiElement element) { final StructuralSearchProfile profile = StructuralSearchUtil.getProfileByPsiElement(element); if (profile == null) { LOG.warn("No StructuralSearchProfile found for language " + element.getLanguage().getID()); return null; } return profile.createMatchingVisitor(this); }
|
getVisitorForElement
|
292,956
|
boolean (@NotNull NodeIterator patternNodes, @NotNull NodeIterator matchNodes) { if (!patternNodes.hasNext()) { while (matchNodes.current() instanceof PsiComment) matchNodes.advance(); return !matchNodes.hasNext(); } final PsiElement current = patternNodes.current(); return matchContext.getPattern().getHandler(current).matchSequentially(patternNodes, matchNodes, matchContext); }
|
matchSequentially
|
292,957
|
void (@NotNull NodeIterator elements) { final CompiledPattern pattern = matchContext.getPattern(); final NodeIterator patternNodes = pattern.getNodes().clone(); final MatchResultImpl saveResult = matchContext.hasResult() ? matchContext.getResult() : null; matchContext.saveMatchedNodes(); try { if (!patternNodes.hasNext()) return; final MatchingHandler firstMatchingHandler = pattern.getHandler(patternNodes.current()); for (; elements.hasNext(); elements.advance()) { matchContext.setResult(null); matchContext.clearMatchedNodes(); final PsiElement elementNode = elements.current(); final boolean patternMatched = firstMatchingHandler.matchSequentially(patternNodes, elements, matchContext); final boolean contextMatched; if (patternMatched) { final MatchingHandler matchingHandler = pattern.getHandler(Configuration.CONTEXT_VAR_NAME); contextMatched = matchingHandler == null || ((SubstitutionHandler)matchingHandler).handle(elementNode, matchContext); } else { contextMatched = false; } if (contextMatched) matchContext.dispatchMatched(); patternNodes.reset(); if (patternMatched) { elements.rewind(); } } } finally { matchContext.setResult(saveResult); matchContext.restoreMatchedNodes(); } }
|
matchContext
|
292,958
|
boolean () { return matchContext.getOptions().isLooseMatching(); }
|
isLeftLooseMatching
|
292,959
|
boolean () { return false; }
|
isRightLooseMatching
|
292,960
|
boolean (@Nullable PsiElement left, @Nullable PsiElement right) { if (left == null) return right == null; return right != null && matchText(left.getText(), right.getText()); }
|
matchText
|
292,961
|
boolean (String left, String right) { return matchContext.getOptions().isCaseSensitiveMatch() ? left.equals(right) : left.equalsIgnoreCase(right); }
|
matchText
|
292,962
|
void (PsiElement patternNode, boolean typedVar, PsiElement matchNode) { final MatchResultImpl ourResult = matchContext.hasResult() ? matchContext.getResult() : null; matchContext.popResult(); if (myResult) { if (typedVar) { final SubstitutionHandler handler = (SubstitutionHandler)matchContext.getPattern().getHandler(patternNode); if (ourResult != null) ourResult.setScopeMatch(true); handler.setNestedResult(ourResult); setResult(handler.handle(matchNode, matchContext)); final MatchResultImpl nestedResult = handler.getNestedResult(); if (nestedResult != null) { // some constraint prevent from adding copyResults(nestedResult); handler.setNestedResult(null); } } else if (ourResult != null) { copyResults(ourResult); } } }
|
scopeMatch
|
292,963
|
void (MatchResult source) { final MatchResultImpl result = matchContext.getResult(); for (MatchResult child : source.getChildren()) result.addChild(child); }
|
copyResults
|
292,964
|
NodeFilter () { return ourFilter; }
|
getFilter
|
292,965
|
void (@NotNull PsiElement element, @NotNull MatchingHandler handler) { MatchingHandler realHandler = context.getPattern().getHandlerSimple(element); if (realHandler instanceof SubstitutionHandler) { ((SubstitutionHandler)realHandler).setMatchHandler(handler); } else { // @todo care about composite handler in this case of simple handler! context.getPattern().setHandler(element, handler); } }
|
setHandler
|
292,966
|
void (@NotNull PsiElement element) { if ((!ourFilter.accepts(element) || StructuralSearchUtil.isIdentifier(element)) && context.getPattern().isRealTypedVar(element) && context.getPattern().getHandlerSimple(element) == null ) { final CompiledPattern pattern = context.getPattern(); String name = pattern.getTypedVarString(element); // name is the same for named element (clazz,methods, etc) and token (name of ... itself) // @todo need fix this final SubstitutionHandler handler = (SubstitutionHandler)pattern.getHandler(name); if (handler == null) return; pattern.setHandler(element, handler); if (context.getOptions().getVariableConstraint(handler.getName()).isPartOfSearchResults()) { handler.setTarget(true); final PsiElement targetNode = pattern.getTargetNode(); if (targetNode == null || targetNode == element.getParent()) { pattern.setTargetNode(element); } } } }
|
handle
|
292,967
|
CompileContext () { return context; }
|
getContext
|
292,968
|
int () { return myCodeBlockLevel; }
|
getCodeBlockLevel
|
292,969
|
void (int codeBlockLevel) { this.myCodeBlockLevel = codeBlockLevel; }
|
setCodeBlockLevel
|
292,970
|
void (@NotNull MatchingHandler handler, @NotNull NodeFilter filter) { if (handler.getFilter() != null && handler.getFilter().getClass() != filter.getClass()) { // for constructor we will have the same handler for class and method and tokens itself handler.setFilter(new CompositeNodeFilter(filter, handler.getFilter())); } else { handler.setFilter(filter); } }
|
setFilter
|
292,971
|
void (@NotNull PsiElement element, @NotNull NodeFilter filter) { context.getPattern().getHandler(element).setFilter(filter); }
|
setFilterSimple
|
292,972
|
List<PsiElement> () { return myLexicalNodes; }
|
getLexicalNodes
|
292,973
|
void (@NotNull PsiElement node) { myLexicalNodes.add(node); }
|
addLexicalNode
|
292,974
|
boolean (@NotNull String pattern) { return ourSubstitutionPattern.matcher(pattern).find(); }
|
hasFragments
|
292,975
|
MatchingHandler (@NotNull String pattern, @NotNull OccurenceKind kind) { return processPatternStringWithFragments(pattern, kind, ourSubstitutionPattern); }
|
processPatternStringWithFragments
|
292,976
|
MatchingHandler (@NotNull String pattern, @NotNull OccurenceKind kind, @NotNull Pattern substitutionPattern) { String content; if (kind == OccurenceKind.LITERAL) { content = pattern.substring(1, pattern.length() - 1); } else if (kind == OccurenceKind.COMMENT || kind == OccurenceKind.TEXT) { content = pattern; } else { assert false; return null; } @NonNls StringBuilder buf = new StringBuilder(content.length()); Matcher matcher = substitutionPattern.matcher(content); List<SubstitutionHandler> handlers = new SmartList<>(); int start = 0; String word; boolean hasLiteralContent = false; SubstitutionHandler handler = null; while (matcher.find()) { word = content.substring(start, matcher.start()); if (!word.isEmpty()) { hasLiteralContent = true; buf.append(MatchUtil.makeExtremeSpacesOptional(MatchUtil.shieldRegExpMetaChars(word))); processTokenizedName(word, kind); } handler = (SubstitutionHandler)getContext().getPattern().getHandler(matcher.group(1)); if (handler == null) throw new MalformedPatternException(); handlers.add(handler); RegExpPredicate predicate = handler.findPredicate(RegExpPredicate.class); if (predicate == null || !predicate.isWholeWords()) { buf.append("(.*?)"); } else { buf.append(".*?\\b(").append(predicate.getRegExp()).append(")\\b.*?"); } if (isSuitablePredicate(predicate, handler)) { processTokenizedName(predicate.getRegExp(), kind); } start = matcher.end(); } word = content.substring(start); if (!word.isEmpty()) { hasLiteralContent = true; buf.append(MatchUtil.makeExtremeSpacesOptional(MatchUtil.shieldRegExpMetaChars(word))); processTokenizedName(word, kind); } if (hasLiteralContent) { if (kind == OccurenceKind.LITERAL) { buf.insert(0, "[\"']"); buf.append("[\"']"); } } if (!handlers.isEmpty()) { return hasLiteralContent ? new LiteralWithSubstitutionHandler(buf.toString(), handlers, context.getOptions().isCaseSensitiveMatch()) : handler; } return null; }
|
processPatternStringWithFragments
|
292,977
|
boolean (RegExpPredicate predicate, @NotNull SubstitutionHandler handler) { return predicate != null && handler.getMinOccurs() != 0 && predicate.couldBeOptimized(); }
|
isSuitablePredicate
|
292,978
|
void (@NotNull String word, boolean endTransaction, @NotNull GlobalCompilingVisitor.OccurenceKind kind, @NotNull CompileContext compileContext) { if (!compileContext.getSearchHelper().doOptimizing()) { return; } final StructuralSearchProfile profile = StructuralSearchUtil.getProfileByFileType(compileContext.getOptions().getFileType()); assert profile != null; if (profile.getReservedWords().contains(word)) return; // skip our special annotations !!! if (kind == GlobalCompilingVisitor.OccurenceKind.CODE) { compileContext.getSearchHelper().addWordToSearchInCode(word); } else if (kind == GlobalCompilingVisitor.OccurenceKind.COMMENT) { compileContext.getSearchHelper().addWordToSearchInComments(word); } else if (kind == GlobalCompilingVisitor.OccurenceKind.LITERAL) { compileContext.getSearchHelper().addWordToSearchInLiterals(word); } else if (kind == GlobalCompilingVisitor.OccurenceKind.TEXT) { compileContext.getSearchHelper().addWordToSearchInText(word); } if (endTransaction) { compileContext.getSearchHelper().endTransaction(); } }
|
addFilesToSearchForGivenWord
|
292,979
|
void (@NotNull String name, @NotNull GlobalCompilingVisitor.OccurenceKind kind) { if (kind == OccurenceKind.LITERAL) name = StringUtil.unescapeStringCharacters(name); for (String word : StringUtil.getWordsInStringLongestFirst(name)) { addFilesToSearchForGivenWord(word, true, kind, getContext()); } }
|
processTokenizedName
|
292,980
|
boolean () { return myScope instanceof GlobalSearchScope; }
|
doOptimizing
|
292,981
|
void () { super.clear(); if (filesToScan != null) { filesToScan.clear(); filesToScan2.clear(); } }
|
clear
|
292,982
|
void (@NotNull String word) { myTransactionStarted = true; VirtualFile[] files = CacheManager.getInstance(myProject) .getVirtualFilesWithWord(word, (short)(IN_CODE | IN_PLAIN_TEXT), (GlobalSearchScope)myScope, myCaseSensitive); process(files); }
|
doAddSearchWordInCode
|
292,983
|
void (@NotNull String word) { myTransactionStarted = true; VirtualFile[] files = CacheManager.getInstance(myProject).getVirtualFilesWithWord(word, IN_PLAIN_TEXT, (GlobalSearchScope)myScope, myCaseSensitive); process(files); }
|
doAddSearchWordInText
|
292,984
|
void (@NotNull String word) { myTransactionStarted = true; VirtualFile[] files = CacheManager.getInstance(myProject).getVirtualFilesWithWord(word, IN_COMMENTS, (GlobalSearchScope)myScope, myCaseSensitive); process(files); }
|
doAddSearchWordInComments
|
292,985
|
void (@NotNull String word) { myTransactionStarted = true; VirtualFile[] files = CacheManager.getInstance(myProject).getVirtualFilesWithWord(word, IN_STRINGS, (GlobalSearchScope)myScope, myCaseSensitive); process(files); }
|
doAddSearchWordInLiterals
|
292,986
|
void () { if (!myTransactionStarted) return; myTransactionStarted = false; super.endTransaction(); Set<VirtualFile> map = filesToScan; if (!map.isEmpty()) map.clear(); filesToScan = filesToScan2; filesToScan2 = map; }
|
endTransaction
|
292,987
|
Set<VirtualFile> () { assert !myTransactionStarted; if (filesToScan == null) { return Collections.emptySet(); } return filesToScan; }
|
getFilesSetToScan
|
292,988
|
void (VirtualFile @NotNull [] files) { if (scanRequest == 0) { Collections.addAll(filesToScan2, files); } else { for (VirtualFile file : files) { if (filesToScan.contains(file)) { filesToScan2.add(file); } } } }
|
process
|
292,989
|
void (@NotNull PsiElement first, PsiElement last) { if (last == first) { first.delete(); } else { first.getParent().deleteChildRange(first, last); } }
|
delete
|
292,990
|
void () { try { PsiElement first = null; PsiElement last = null; for (PsiElement element : elements) { if (!element.isValid()) continue; if (first == null) { first = last = element; } else if (last.getNextSibling() == element) { last = element; } else { delete(first, last); first = last = element; } } if (first != null) { delete(first, last); } } finally { elements.clear(); } }
|
run
|
292,991
|
void (PsiElement @NotNull [] topLevelElements) { final CompileContext context = myCompilingVisitor.getContext(); final CompiledPattern pattern = context.getPattern(); if (pattern.getStrategy() == null) { final MatchOptions options = context.getOptions(); pattern.setStrategy(new XmlMatchingStrategy(options.getDialect())); } for (PsiElement element : topLevelElements) { element.accept(this); optimize(element); pattern.setHandler(element, new TopLevelMatchingHandler(pattern.getHandler(element))); } }
|
compile
|
292,992
|
void (@NotNull PsiElement element) { element.accept(myOptimizer); }
|
optimize
|
292,993
|
void (@NotNull XmlTag tag) { if (!handleWord(tag.getName(), CODE, myCompilingVisitor.getContext())) return; super.visitXmlTag(tag); }
|
visitXmlTag
|
292,994
|
void (@NotNull XmlAttribute attribute) { if (!handleWord(attribute.getName(), CODE, myCompilingVisitor.getContext())) return; handleWord(attribute.getValue(), CODE, myCompilingVisitor.getContext()); super.visitXmlAttribute(attribute); }
|
visitXmlAttribute
|
292,995
|
void (@NotNull XmlToken token) { super.visitXmlToken(token); final IElementType tokenType = token.getTokenType(); if (tokenType == XmlTokenType.XML_COMMENT_CHARACTERS || tokenType == XmlTokenType.XML_DATA_CHARACTERS) { handleWord(token.getText(), TEXT, myCompilingVisitor.getContext()); } }
|
visitXmlToken
|
292,996
|
void (@NotNull PsiElement element) { if (!(element.getLanguage() instanceof XMLLanguage) && StructuralSearchUtil.compileForeignElement(element, myCompilingVisitor)) { return; } myCompilingVisitor.handle(element); super.visitElement(element); }
|
visitElement
|
292,997
|
void (@NotNull XmlToken token) { final IElementType tokenType = token.getTokenType(); if (tokenType != XmlTokenType.XML_NAME && tokenType != XmlTokenType.XML_TAG_NAME && tokenType != XmlTokenType.XML_COMMENT_CHARACTERS && tokenType != XmlTokenType.XML_DATA_CHARACTERS) { return; } super.visitXmlToken(token); if (tokenType == XmlTokenType.XML_DATA_CHARACTERS) { myCompilingVisitor.setFilterSimple(token, TagValueFilter.getInstance()); } }
|
visitXmlToken
|
292,998
|
void (@NotNull XmlText text) { super.visitXmlText(text); if (myCompilingVisitor.getContext().getPattern().isRealTypedVar(text)) { myCompilingVisitor.setFilterSimple(text, TagValueFilter.getInstance()); } }
|
visitXmlText
|
292,999
|
void (@NotNull XmlTag tag) { super.visitXmlTag(tag); // there are a lot of implementations of XmlTag which we should be able to match myCompilingVisitor.setFilterSimple(tag, element -> element instanceof XmlTag); }
|
visitXmlTag
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.