Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
77,200 | boolean () { return true; } | isSoft |
77,201 | boolean () { return true; } | isAllowDollarInNames |
77,202 | GlobalSearchScope (Project project) { return GlobalSearchScope.allScope(project); } | getScope |
77,203 | Set<PsiPackage> () { if (myIndex == 0) return myReferenceSet.getInitialContext(); Set<PsiPackage> psiPackages = new HashSet<>(); for (ResolveResult resolveResult : myReferenceSet.getReference(myIndex - 1).doMultiResolve()) { PsiElement psiElement = resolveResult.getElement(); if (psiElement instanceof PsiPackage) { psi... | getContext |
77,204 | String () { //noinspection UnresolvedPropertyKey return JavaErrorBundle.message("cannot.resolve.package"); } | getUnresolvedMessagePattern |
77,205 | PackageReferenceSet () { return myReferenceSet; } | getReferenceSet |
77,206 | void (@NotNull PsiScopeProcessor processor) { if (processor instanceof JavaCompletionProcessor) { Map<CustomizableReferenceProvider.CustomizationKey, Object> options = getOptions(); if (options != null && (JavaClassReferenceProvider.SUPER_CLASSES.getValue(options) != null || JavaClassReferenceProvider.NOT_INTERFACE.get... | processVariants |
77,207 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { return !(element instanceof PsiClass || element instanceof PsiPackage) || processor.execute(element, state); } | execute |
77,208 | void (@NotNull Event event, Object associated) { processor.handleEvent(event, associated); } | handleEvent |
77,209 | boolean () { String s = getElement().getText(); return isStaticClassReference(s, true); } | isDefinitelyStatic |
77,210 | boolean (String s, boolean strict) { if (myIndex == 0) { return false; } char c = s.charAt(getRangeInElement().getStartOffset() - 1); return myJavaClassReferenceSet.isStaticSeparator(c, strict); } | isStaticClassReference |
77,211 | boolean () { return myJavaClassReferenceSet.canReferencePackage(myIndex); } | canReferencePackage |
77,212 | PsiElement () { return myJavaClassReferenceSet.getElement(); } | getElement |
77,213 | boolean (@NotNull PsiElement element) { return (element instanceof PsiMember || element instanceof PsiPackage) && super.isReferenceTo(element); } | isReferenceTo |
77,214 | TextRange () { return myRange; } | getRangeInElement |
77,215 | String () { return myText; } | getCanonicalText |
77,216 | boolean () { return myJavaClassReferenceSet.isSoft(); } | isSoft |
77,217 | String (PsiClass psiClass) { boolean jvmFormat = Boolean.TRUE.equals(JavaClassReferenceProvider.JVM_FORMAT.getValue(getOptions())); return jvmFormat ? ClassUtil.getJVMClassName(psiClass) : psiClass.getQualifiedName(); } | getQualifiedClassNameToInsert |
77,218 | PsiElement () { return advancedResolve(true).getElement(); } | resolveInner |
77,219 | List<String> () { List<String> values = JavaClassReferenceProvider.SUPER_CLASSES.getValue(getOptions()); return values == null ? Collections.emptyList() : values; } | getSuperClasses |
77,220 | List<LookupElement> (@NotNull PsiPackage aPackage) { ArrayList<LookupElement> list = new ArrayList<>(); int startOffset = StringUtil.isEmpty(aPackage.getName()) ? 0 : aPackage.getQualifiedName().length() + 1; GlobalSearchScope scope = getScope(getJavaContextFile()); for (PsiPackage subPackage : aPackage.getSubPackages(... | processPackage |
77,221 | boolean (PsiClass clazz, @Nullable ClassKind classKind, boolean instantiatable, boolean concrete, boolean notInterface, boolean notEnum) { if (classKind == ClassKind.ANNOTATION) return clazz.isAnnotationType(); if (classKind == ClassKind.ENUM) return clazz.isEnum(); if (instantiatable) { if (PsiUtil.isInstantiatable(cl... | isClassAccepted |
77,222 | JavaResolveResult (boolean incompleteCode) { PsiFile file = getJavaContextFile(); ResolveCache resolveCache = ResolveCache.getInstance(file.getProject()); return (JavaResolveResult) resolveCache.resolveWithCaching(this, MyResolver.INSTANCE, false, false,file)[0]; } | advancedResolve |
77,223 | PsiFile () { return myJavaClassReferenceSet.getProvider().getContextFile(getElement()); } | getJavaContextFile |
77,224 | JavaResolveResult (@NotNull PsiFile containingFile) { PsiElement psiElement = getElement(); if (!psiElement.isValid()) return JavaResolveResult.EMPTY; String elementText = psiElement.getText(); PsiElement context = getContext(); if (context instanceof PsiClass) { if (isStaticClassReference(elementText, false)) { PsiCla... | doAdvancedResolve |
77,225 | JavaResolveResult (@NotNull PsiElement psiElement, @NotNull String qName, @NotNull PsiFile containingFile) { PsiManager manager = containingFile.getManager(); GlobalSearchScope scope = getScope(containingFile); if (myIndex == myJavaClassReferenceSet.getReferences().length - 1) { PsiClass aClass = JavaPsiFacade.getInsta... | advancedResolveInner |
77,226 | GlobalSearchScope (@NotNull PsiFile containingFile) { Project project = containingFile.getProject(); GlobalSearchScope scope = myJavaClassReferenceSet.getProvider().getScope(project); if (scope == null) { Module module = ModuleUtilCore.findModuleForPsiElement(containingFile); return module == null ? GlobalSearchScope.a... | getScope |
77,227 | void (@NotNull PsiPackage context, String @NotNull [] extendClasses, Consumer<? super LookupElement> result) { GlobalSearchScope packageScope = PackageScope.packageScope(context, true); GlobalSearchScope scope = myJavaClassReferenceSet.getProvider().getScope(getElement().getProject()); if (scope != null) { packageScope... | processSubclassVariants |
77,228 | LookupElementBuilder (@NotNull PsiClass clazz) { return JavaLookupElementBuilder.forClass(clazz, getQualifiedClassNameToInsert(clazz), true) .withPresentableText(Objects.requireNonNull(clazz.getName())); } | createSubclassLookupValue |
77,229 | JavaClassReferenceSet () { return myJavaClassReferenceSet; } | getJavaClassReferenceSet |
77,230 | String () { return myJavaClassReferenceSet.getUnresolvedMessagePattern(myIndex); } | getUnresolvedMessagePattern |
77,231 | String () { return getClass().getName() + "(" + getRangeInElement() + ", provider=" + myJavaClassReferenceSet.getProvider() + "} | toString |
77,232 | boolean () { return true; } | disableNonSlashedPaths |
77,233 | char () { return ','; } | getSeparator |
77,234 | boolean () { return soft; } | isSoft |
77,235 | TreeElement (TreeElement element, Map<Object, Object> decodingState) { boolean shallDecodeEscapedTexts = shallEncodeEscapedTexts(element, decodingState); if (element instanceof CompositeElement) { IElementType elementType = element.getElementType(); if (elementType == JavaElementType.JAVA_CODE_REFERENCE || elementType ... | decodeInformation |
77,236 | boolean (ASTNode element) { PsiElement psi = element.getPsi(); if (psi == null || !psi.isValid()) return false; PsiFile file = psi.getContainingFile(); Language baseLanguage = file.getViewProvider().getBaseLanguage(); return baseLanguage instanceof JspxLanguage && file.getLanguage() != baseLanguage; } | conversionMayApply |
77,237 | void (TreeElement element, ASTNode original, Map<Object, Object> encodingState) { boolean shallEncodeEscapedTexts = shallEncodeEscapedTexts(original, encodingState); if (original instanceof CompositeElement) { IElementType originalType = original.getElementType(); if (originalType == JavaElementType.JAVA_CODE_REFERENCE... | encodeInformation |
77,238 | Boolean (ASTNode original, Map<Object, Object> encodingState) { Boolean shallEncodeEscapedTexts = (Boolean)encodingState.get(ESCAPEMENT_ENGAGED); if (shallEncodeEscapedTexts == null) { shallEncodeEscapedTexts = conversionMayApply(original); encodingState.put(ESCAPEMENT_ENGAGED, shallEncodeEscapedTexts); } return shallE... | shallEncodeEscapedTexts |
77,239 | boolean (ASTNode element) { ASTNode leaf = element; while (leaf != null) { if (leaf instanceof OuterLanguageElement) { return leaf.getText().contains("<![CDATA["); } leaf = TreeUtil.prevLeaf(leaf); } return false; } | isInCData |
77,240 | void (TreeElement ref, ASTNode original) { IElementType originalType = original.getElementType(); if (originalType == JavaElementType.REFERENCE_EXPRESSION) { PsiJavaCodeReferenceElement javaRefElement = SourceTreeToPsiMap.treeToPsiNotNull(original); JavaResolveResult resolveResult = javaRefElement.advancedResolve(false... | encodeInformationInRef |
77,241 | PsiLiteral (@NotNull String value, @NotNull PsiElement context) { return (PsiLiteral)JavaPsiFacade.getElementFactory(context.getProject()).createExpressionFromText("\"" + StringUtil.escapeStringCharacters(value) + "\"", null); } | createLiteralValue |
77,242 | void (@NotNull Disposable parent) { injectVariousStuffEverywhere(parent, myPsiManager); Project project = myPsiManager.getProject(); Language ql = Language.findLanguageByID("JPAQL"); Language js = Language.findLanguageByID("JavaScript"); registerForStringVarInitializer(parent, project, ql, "ql", null, null); registerFo... | injectAll |
77,243 | void (Disposable parent, final Project project, final Language language, final String paramName) { if (language == null) return; final ConcatenationAwareInjector injector = (injectionPlacesRegistrar, operands) -> { PsiElement operand = operands[0]; if (!(operand instanceof PsiLiteralExpression)) return; if (!(operand.g... | registerForParameterValue |
77,244 | void (@NotNull Disposable parent, @NotNull final Project project, final Language language, @NotNull @NonNls final String varName, @NonNls final String prefix, @NonNls final String suffix) { if (language == null) return; final ConcatenationAwareInjector injector = (injectionPlacesRegistrar, operands) -> { if (operands[0... | registerForStringVarInitializer |
77,245 | void (@NotNull Disposable parent, final PsiManager psiManager) { final Language ql = Language.findLanguageByID("JPAQL"); final Language js = Language.findLanguageByID("JavaScript 1.8"); final Language html = Language.findLanguageByID("HTML"); if (ql == null || js == null) return; final Language ecma4 = Language.findLan... | injectVariousStuffEverywhere |
77,246 | void (@NotNull MultiHostRegistrar registrar, @NotNull PsiElement context) { XmlAttributeValue value = (XmlAttributeValue)context; PsiElement parent1 = value.getParent(); if (parent1 instanceof XmlAttribute) { @NonNls String attrName = ((XmlAttribute)parent1).getLocalName(); if ("jsInBraces".equals(attrName)) { registra... | getLanguagesToInject |
77,247 | void (final PsiLanguageInjectionHost host, final InjectedLanguagePlaces placesToInject, final Language language) { inject(host, placesToInject, language, null, null); } | inject |
77,248 | void (final PsiLanguageInjectionHost host, final InjectedLanguagePlaces placesToInject, final Language language, @NonNls String prefix, String suffix) { TextRange insideQuotes = textRangeToInject(host); placesToInject.addPlace(language, insideQuotes, prefix, suffix); } | inject |
77,249 | TextRange (PsiLanguageInjectionHost host) { ASTNode[] children = host.getNode().getChildren(null); TextRange insideQuotes = new ProperTextRange(0, host.getTextLength()); if (children.length > 1 && children[0].getElementType() == XmlTokenType.XML_ATTRIBUTE_VALUE_START_DELIMITER) { insideQuotes = new ProperTextRange(chil... | textRangeToInject |
77,250 | InjectedFileChangesHandler (List<? extends PsiLanguageInjectionHost.Shred> shreds, Editor hostEditor, Document newDocument, PsiFile injectedFile) { if (Registry.is("injections.java.fragment.editor.new") && !hasBlockLiterals(shreds) && !hasSnippet(shreds)) { return new JavaInjectedFileChangesHandler(shreds, hostEditor, ... | createFileChangesHandler |
77,251 | boolean (List<? extends PsiLanguageInjectionHost.Shred> shreds) { for (PsiLanguageInjectionHost.Shred shred : shreds) { if (shred.getHost() instanceof PsiSnippetDocTag) return true; } return false; } | hasSnippet |
77,252 | boolean (List<? extends PsiLanguageInjectionHost.Shred> shreds) { for (PsiLanguageInjectionHost.Shred shred : shreds) { PsiLanguageInjectionHost host = shred.getHost(); if (!(host instanceof PsiLiteralExpression)) continue; if (((PsiLiteralExpression)host).isTextBlock()) return true; } return false; } | hasBlockLiterals |
77,253 | boolean () { return myAltFullRange.isValid(); } | isValid |
77,254 | void (@NotNull DocumentEvent e) { final PsiFile origPsiFile = PsiDocumentManager.getInstance(myProject).getPsiFile(myHostDocument); String newText = myFragmentDocument.getText(); // prepare guarded blocks Map<String, String> replacementMap = new LinkedHashMap<>(); int count = 0; for (RangeMarker o : ContainerUtil.rever... | commitToOriginal |
77,255 | boolean (@NotNull PsiFile newInjectedFile, @NotNull TextRange newHostRange) { DocumentWindow documentWindow = InjectedLanguageUtil.getDocumentWindow(newInjectedFile); if (documentWindow == null || documentWindow.getDelegate() != myAltFullRange.getDocument()) { return false; } return super.tryReuse(newInjectedFile, newH... | tryReuse |
77,256 | boolean (@NotNull TextRange hostRange) { return hostRange.intersects(myAltFullRange.getStartOffset(), myAltFullRange.getEndOffset()); } | handlesRange |
77,257 | void (Document doc, int offset) { if (doc.getCharsSequence().charAt(offset) == '\'') { doc.replaceString(offset, offset + 1, "\""); } } | fixDocumentQuotes |
77,258 | void (@NotNull MultiHostRegistrar registrar, @NotNull PsiElement context) { if (!(context instanceof PsiSnippetDocTagImpl snippet)) return; final Language language = getLanguage(snippet); final List<TextRange> ranges = snippet.getContentRanges(); if (ranges.isEmpty()) return; registrar.startInjecting(language); for (Te... | getLanguagesToInject |
77,259 | Language (@NotNull PsiSnippetDocTagImpl snippet) { PsiSnippetDocTagValue valueElement = snippet.getValueElement(); if (valueElement == null) return JShellLanguage.INSTANCE; final PsiSnippetAttributeList attributeList = valueElement.getAttributeList(); PsiSnippetAttribute attribute = attributeList.getAttribute(PsiSnippe... | getLanguage |
77,260 | TextRange (ASTNode node, TextRange textRange, int shift) { return shiftIndentInsideWithPsi(node, textRange, shift); } | shiftIndentInsideRange |
77,261 | TextRange (ASTNode node, final TextRange textRange, final int shift) { if (node != null && node.getTextRange().equals(textRange) && ShiftIndentInsideHelper.mayShiftIndentInside(node)) { PsiFile file = node.getPsi().getContainingFile(); return new ShiftIndentInsideHelper(file).shiftIndentInside(node, shift).getTextRange... | shiftIndentInsideWithPsi |
77,262 | String (final TextRange textRange, String whiteSpace, ASTNode leafElement) { if (!myCanModifyAllWhiteSpaces) { if (leafElement.getElementType() == TokenType.WHITE_SPACE) return null; ASTNode prevNode = TreeUtil.prevLeaf(leafElement); if (prevNode != null) { IElementType type = prevNode.getElementType(); if(type == Toke... | replaceWithPsiInLeaf |
77,263 | PsiElement (@NotNull PsiElement source, @NotNull CodeStyleSettings settings) { return isApplicable(source) ? new BraceEnforcer(settings).process(source) : source; } | processElement |
77,264 | TextRange (@NotNull PsiFile source, @NotNull TextRange rangeToReformat, @NotNull CodeStyleSettings settings) { return isApplicable(source) ? new BraceEnforcer(settings).processText(source, rangeToReformat) : rangeToReformat; } | processText |
77,265 | boolean (@NotNull PsiElement source) { if (source.isValid()) { PsiFile file = source.getContainingFile(); return file instanceof PsiJavaFile || file instanceof JavaDummyHolder; } return false; } | isApplicable |
77,266 | PsiImportList (@NotNull PsiJavaFile file, @NotNull Predicate<? super Import> filter) { PsiImportList oldList = file.getImportList(); if (oldList == null) return null; // Java parser works in a way that comments may be included to the import list, e.g.: // import a; // /* comment */ // import b; // We want to preserve t... | prepareOptimizeImportsResult |
77,267 | void (@NotNull List<Import> resultList, @NotNull JavaCodeStyleSettings settings, @NotNull Map<String, Boolean> outClassesOrPackagesToImportOnDemand) { Object2IntMap<String> packageToCountMap = new Object2IntOpenHashMap<>(); Object2IntMap <String> classToCountMap = new Object2IntOpenHashMap<>(); for (Import anImport : r... | collectOnDemandImports |
77,268 | List<Import> (@NotNull List<Import> imports, @NotNull JavaCodeStyleSettings settings) { int[] entryForName = ArrayUtil.newIntArray(imports.size()); PackageEntry[] entries = settings.IMPORT_LAYOUT_TABLE.getEntries(); for(int i = 0; i < imports.size(); i++){ Import anImport = imports.get(i); entryForName[i] = findEntryIn... | sortItemsAccordingToSettings |
77,269 | Set<String> (@NotNull PsiJavaFile file, @NotNull Collection<Import> imports, @NotNull Set<String> onDemandImports) { GlobalSearchScope resolveScope = file.getResolveScope(); String thisPackageName = file.getPackageName(); Set<String> implicitlyImportedPackages = Set.of(file.getImplicitlyImportedPackages()); JavaPsiFaca... | findSingleImports |
77,270 | boolean (@NotNull PsiMember member, @NotNull PsiResolveHelper resolveHelper, @NotNull PsiFile psiFile, @NotNull PsiClass aClass, @NotNull @NlsSafe String prefix) { if (member.hasModifierProperty(PsiModifier.STATIC) && resolveHelper.isAccessible(member, psiFile, null)) { PsiClass containingClass = member.getContainingCl... | checkMemberAccessibility |
77,271 | Set<String> (@NotNull PsiJavaFile file, @NotNull Map<String, Boolean> onDemandImports) { List<String> onDemands = new ArrayList<>(Arrays.asList(file.getImplicitlyImportedPackages())); for (String onDemand : onDemandImports.keySet()) { if (!onDemands.contains(onDemand)) { onDemands.add(onDemand); } } if (onDemands.size(... | calculateOnDemandImportConflicts |
77,272 | void (@NotNull PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); if (reference.getQualifier() != null) return; JavaResolveResult resolveResult = reference.advancedResolve(false); if (resolveResult.getElement() instanceof PsiClass psiClass && conflicts.contains(psiClass.getName())) { if (r... | visitReferenceElement |
77,273 | StringBuilder (@NotNull List<Import> imports, @NotNull Set<String> packagesOrClassesToImportOnDemand, @NotNull Set<String> namesToUseSingle, boolean stringTemplates) { Set<Import> importedPackagesOrClasses = new HashSet<>(); @NonNls StringBuilder buffer = new StringBuilder(); for (Import importedName : imports) { Strin... | buildImportListText |
77,274 | boolean (@NotNull PsiJavaFile file, @NotNull PsiClass refClass) { return addImport(file, refClass, false); } | addImport |
77,275 | boolean (@NotNull PsiJavaFile file, @NotNull PsiClass refClass, boolean forceReimport) { JavaPsiFacade facade = JavaPsiFacade.getInstance(file.getProject()); PsiElementFactory factory = facade.getElementFactory(); PsiResolveHelper helper = facade.getResolveHelper(); String className = refClass.getQualifiedName(); if (c... | addImport |
77,276 | PsiImportStatement (@NotNull PsiJavaFile file, @NotNull String shortName, @NotNull String fqName) { PsiImportList importList = file.getImportList(); if (importList != null) { for (PsiImportStatement statement : importList.getImportStatements()) { PsiJavaCodeReferenceElement ref = statement.getImportReference(); if (!st... | findUnusedSingleImport |
77,277 | boolean (@NotNull PsiJavaFile file, PsiClass curRefClass) { if (curRefClass != null) { String curRefClassQualifiedName = curRefClass.getQualifiedName(); return curRefClassQualifiedName != null && ArrayUtil.find(file.getImplicitlyImportedPackages(), StringUtil.getPackageName(curRefClassQualifiedName)) < 0; } return fals... | containsInCurrentPackage |
77,278 | void (@NotNull PsiJavaFile file, @NotNull JavaPsiFacade facade, @NotNull PsiResolveHelper helper, @NotNull String packageName, @NotNull Collection<String> onDemandRefs, @NotNull List<? super PsiClass> outClassesToReimport) { if (onDemandRefs.isEmpty()) { return; } PsiPackage aPackage = facade.findPackage(packageName); ... | calcClassesToReimport |
77,279 | List<PsiJavaCodeReferenceElement> (@NotNull PsiJavaFile file, @NotNull String packageName) { PsiClass[] refs = file.getSingleClassImports(true); List<PsiJavaCodeReferenceElement> array = new ArrayList<>(refs.length); for (PsiClass ref1 : refs) { String className = ref1.getQualifiedName(); if (getPackageOrClassName(clas... | getImportsFromPackage |
77,280 | PsiClass (@NotNull PsiJavaFile file, @NotNull String shortClassName) { PsiClass[] refs = file.getSingleClassImports(true); for (PsiClass ref : refs) { String className = ref.getQualifiedName(); if (className != null && PsiNameHelper.getShortClassName(className).equals(shortClassName)) { return ref; } } for (PsiClass aC... | findSingleImportByShortName |
77,281 | void (@NotNull PsiElement element) { if (foundRef[0]) return; super.visitElement(element); } | visitElement |
77,282 | void (@NotNull PsiJavaCodeReferenceElement reference) { if (shortClassName.equals(reference.getReferenceName()) && file.getManager().areElementsEquivalent(reference.resolve(), aClass)) { foundRef[0] = true; } super.visitReferenceElement(reference); } | visitReferenceElement |
77,283 | PsiPackage (@NotNull PsiJavaFile file, @NotNull String packageName) { PsiElement[] refs = file.getOnDemandImports(false, true); for (PsiElement ref : refs) { if (ref instanceof PsiPackage psiPackage && psiPackage.getQualifiedName().equals(packageName)) { return psiPackage; } } return null; } | findImportOnDemand |
77,284 | boolean (@NotNull PsiJavaFile file, @NotNull String fullyQualifiedName) { String className = extractClassName(file, fullyQualifiedName); Project project = file.getProject(); PsiResolveHelper resolveHelper = PsiResolveHelper.getInstance(project); PsiClass psiClass = resolveHelper.resolveReferencedClass(className, file);... | isAlreadyImported |
77,285 | String (@NotNull PsiJavaFile file, @NotNull String fullyQualifiedName) { for (PsiClass aClass : file.getClasses()) { String outerClassName = aClass.getQualifiedName(); if (outerClassName != null && fullyQualifiedName.startsWith(outerClassName)) { return fullyQualifiedName.substring(outerClassName.lastIndexOf('.') + 1);... | extractClassName |
77,286 | ASTNode (@NotNull PsiImportList list, @NotNull PsiImportStatementBase statement) { PsiJavaCodeReferenceElement ref = statement.getImportReference(); if (ref == null) return null; int entryIndex = findEntryIndex(statement); PsiImportStatementBase[] allStatements = list.getAllImportStatements(); int[] entries = ArrayUtil... | getDefaultAnchor |
77,287 | int (@NotNull PsiImportStatementBase statement1, @NotNull PsiImportStatementBase statement2) { int index1 = findEntryIndex(statement1); int index2 = findEntryIndex(statement2); if (index1 == index2) return 0; if (index1 > index2) { int t = index1; index1 = index2; index2 = t; } PackageEntry[] entries = mySettings.IMPOR... | getEmptyLinesBetween |
77,288 | boolean (@NotNull String packageName, int classCount, boolean isStaticImportNeeded, @NotNull JavaCodeStyleSettings settings) { if (!settings.USE_SINGLE_CLASS_IMPORTS) return true; int limitCount = isStaticImportNeeded ? settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND : settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND; if (cla... | isToUseImportOnDemand |
77,289 | int (@NotNull String packageName, boolean isStatic, PackageEntry @NotNull [] entries) { PackageEntry bestEntry = null; int bestEntryIndex = -1; int allOtherStaticIndex = -1; int allOtherIndex = -1; for(int i = 0; i < entries.length; i++){ PackageEntry entry = entries[i]; if (entry == PackageEntry.ALL_OTHER_STATIC_IMPOR... | findEntryIndex |
77,290 | boolean (@NotNull PsiJavaFile file, @NotNull PsiClass psiClass, @NotNull String referenceName) { Collection<Import> resultList = collectNamesToImport(file, new ArrayList<>()); String qualifiedName = psiClass.getQualifiedName(); for (Import anImport : resultList) { if (anImport.isStatic && referenceName.equals(StringUti... | hasConflictingOnDemandImport |
77,291 | Collection<Import> (@NotNull PsiJavaFile file, @NotNull List<? super PsiElement> comments) { Set<Import> imports = new HashSet<>(); JspFile jspFile = JspPsiUtil.getJspFile(file); collectNamesToImport(imports, comments, file, jspFile); if (jspFile != null) { PsiFile[] files = ArrayUtil.mergeArrays(JspSpiUtil.getIncludin... | collectNamesToImport |
77,292 | void (@NotNull Set<? super Import> imports, @NotNull List<? super PsiElement> comments, @NotNull PsiJavaFile file, @Nullable PsiFile context) { String packageName = file.getPackageName(); List<PsiFile> roots = file.getViewProvider().getAllFiles(); for (PsiElement root : roots) { addNamesToImport(imports, comments, root... | collectNamesToImport |
77,293 | void (@NotNull Set<? super Import> imports, @NotNull List<? super PsiElement> comments, @NotNull PsiElement scope, @NotNull String thisPackageName, @Nullable PsiFile context) { if (scope instanceof PsiImportList) return; Queue<PsiElement> queue = new ArrayDeque<>(); queue.add(scope); while (!queue.isEmpty()) { PsiEleme... | addNamesToImport |
77,294 | void (@NotNull Set<? super Import> namesToImport, @NotNull PsiJavaFile file) { PsiImportList importList = file.getImportList(); PsiImportStatementBase[] imports = importList == null ? PsiImportStatementBase.EMPTY_ARRAY : importList.getAllImportStatements(); Map<String, Import> unresolvedNames = new HashMap<>(); @NotNul... | addUnresolvedImportNames |
77,295 | void (@NotNull PsiJavaCodeReferenceElement reference) { if (reference.getQualifier() == null) { String name = reference.getReferenceName(); Import unresolvedImport = unresolvedNames.get(name); if (reference.multiResolve(false).length == 0) { hasResolveProblem[0] = true; if (unresolvedImport != null) { namesToImport.add... | visitReferenceElement |
77,296 | boolean (@Nullable String className, @NotNull PsiJavaFile file) { if (className == null) return false; for (String packageName : file.getImplicitlyImportedPackages()) { if (hasPackage(className, packageName)) return true; } return false; } | isImplicitlyImported |
77,297 | boolean (@NotNull String className, @NotNull String packageName) { if (!className.startsWith(packageName)) return false; if (className.length() == packageName.length()) return false; if (!packageName.isEmpty() && className.charAt(packageName.length()) != '.') return false; return className.indexOf('.', packageName.leng... | hasPackage |
77,298 | String (@NotNull String className) { int dotIndex = className.lastIndexOf('.'); return dotIndex < 0 ? "" : className.substring(0, dotIndex); } | getPackageOrClassName |
77,299 | record (String name, boolean isStatic) {} | Import |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.