Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
72,200 | String (@NotNull String normalizedPath) { var separatorIndex = normalizedPath.indexOf(SEPARATOR); return separatorIndex > 0 ? normalizedPath.substring(0, separatorIndex + SEPARATOR.length()) : ""; } | extractRootPath |
72,201 | ArchiveHandler (@NotNull VirtualFile entryFile) { checkSubscription(); var homePath = extractLocalPath(VfsUtilCore.getRootFile(entryFile).getPath()); return myHandlers.computeIfAbsent(homePath, key -> { var handler = new JrtHandler(key); loadReleaseFileIntoVfs(key); return handler; }); } | getHandler |
72,202 | void (String homePath) { var releasePath = homePath + "/release"; VfsImplUtil.refreshAndFindFileByPath(LocalFileSystem.getInstance(), releasePath, file -> { if (file == null) { Logger.getInstance(JrtFileSystemImpl.class).warn("Cannot load into VFS: " + releasePath); } }); } | loadReleaseFileIntoVfs |
72,203 | void () { if (mySubscribed.getAndSet(true)) return; var app = ApplicationManager.getApplication(); if (app.isDisposed()) return; // we might perform a shutdown activity that includes visiting archives (IDEA-181620) Disposer.register(app, this); app.getMessageBus().connect(this).subscribe(VirtualFileManager.VFS_CHANGES,... | checkSubscription |
72,204 | void (@NotNull List<? extends @NotNull VFileEvent> events) { Set<VirtualFile> toRefresh = null; for (var e : events) { if (e.getFileSystem() instanceof LocalFileSystem) { String homePath = null; if (e instanceof VFileContentChangeEvent cce) { var file = cce.getFile(); if ("release".equals(file.getName())) { homePath = ... | after |
72,205 | VirtualFile (@NotNull String path) { return VfsImplUtil.findFileByPath(this, path); } | findFileByPath |
72,206 | VirtualFile (@NotNull String path) { return VfsImplUtil.findFileByPathIfCached(this, path); } | findFileByPathIfCached |
72,207 | VirtualFile (@NotNull String path) { return VfsImplUtil.refreshAndFindFileByPath(this, path); } | refreshAndFindFileByPath |
72,208 | void (boolean asynchronous) { VfsImplUtil.refresh(this, asynchronous); } | refresh |
72,209 | boolean (@NotNull VirtualFile local) { var path = local.toNioPath(); return JdkUtil.isModularRuntime(path) && !JdkUtil.isExplodedModularRuntime(path); } | isCorrectFileType |
72,210 | void (@NotNull String localPath) { if (!ApplicationManager.getApplication().isUnitTestMode()) throw new IllegalStateException(); var handler = myHandlers.remove(localPath); if (handler == null) throw new IllegalArgumentException(localPath + " not in " + myHandlers.keySet()); handler.clearCaches(); } | release |
72,211 | EditorTextField (Project project, boolean isClassAccepted, JavaCodeFragment.VisibilityChecker visibilityChecker, FileType fileType) { if (project.isDefault()) { return new EditorTextField(); } else { PsiElement defaultPackage = JavaPsiFacade.getInstance(project).findPackage(""); JavaCodeFragmentFactory factory = JavaCo... | createEditorTextField |
72,212 | void (String text) { getChildComponent().setText(StringUtil.notNullize(text)); } | setText |
72,213 | String () { return getChildComponent().getText(); } | getText |
72,214 | String () { return getChildComponent().getText().trim(); } | getText |
72,215 | void (final String text) { getChildComponent().setText(text); } | setText |
72,216 | boolean () { return !getChildComponent().getEditorEx().isViewer(); } | isEditable |
72,217 | void (String[] history) { getChildComponent().setHistory(history); } | setHistory |
72,218 | void (String item) { getChildComponent().prependItem(item); } | prependItem |
72,219 | void (String item) { getChildComponent().appendItem(item); } | appendItem |
72,220 | ReferenceEditorWithBrowseButton (final ActionListener browseActionListener, final String text, final Project project, final boolean toAcceptClasses) { return new ReferenceEditorWithBrowseButton(browseActionListener, project, (NullableFunction<String, Document>)s -> createDocument(s, project, toAcceptClasses), text); } | createReferenceEditorWithBrowseButton |
72,221 | Document (final String text, Project project, boolean isClassesAccepted) { return createDocument(text, project, isClassesAccepted, JavaCodeFragment.VisibilityChecker.EVERYTHING_VISIBLE); } | createDocument |
72,222 | Document (final String text, Project project, boolean isClassesAccepted, JavaCodeFragment.VisibilityChecker visibilityChecker) { final PsiPackage defaultPackage = JavaPsiFacade.getInstance(project).findPackage(""); final JavaCodeFragmentFactory factory = JavaCodeFragmentFactory.getInstance(project); final JavaCodeFragm... | createDocument |
72,223 | Document (final String text, Project project) { final PsiPackage defaultPackage = JavaPsiFacade.getInstance(project).findPackage(""); final JavaCodeFragmentFactory factory = JavaCodeFragmentFactory.getInstance(project); final JavaCodeFragment fragment = factory.createTypeCodeFragment(text, defaultPackage, true); fragme... | createTypeDocument |
72,224 | String () { return JavaBundle.message("intention.text.annotate.externally"); } | getFamilyName |
72,225 | boolean (@NotNull Project project, Editor editor, PsiFile file) { PsiAnnotation annotation = PsiTreeUtil.getParentOfType(file.findElementAt(editor.getCaretModel().getOffset()), PsiAnnotation.class); if (annotation != null && annotation.getQualifiedName() != null && annotation.getManager().isInProject(annotation)) { Psi... | isAvailable |
72,226 | boolean () { return false; } | startInWriteAction |
72,227 | List<PsiFile> (PsiFile file, PsiModifierListOwner owner, ExternalAnnotationsManager externalAnnotationsManager) { List<PsiFile> files = externalAnnotationsManager.findExternalAnnotationsFiles(owner); if (files != null) { List<PsiFile> elements = new ArrayList<>(files); elements.add(file); return elements; } return Coll... | getFilesToWrite |
72,228 | boolean (PsiMember member) { if (member instanceof PsiClass && LanguageLevelUtil.getLastIncompatibleLanguageLevel(member, PsiUtil.getLanguageLevel(element)) == null) { if (!JavaPsiFacade.getInstance(project).getResolveHelper().isAccessible(member, element, null)) { return true; } types.addAll(acceptanceChecker.apply((P... | processInReadAction |
72,229 | void (@NotNull ProgressIndicator indicator) { final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); final GlobalSearchScope allScope = GlobalSearchScope.allScope(project); final PsiClass functionalInterfaceClass = ReadAction.compute(() -> psiFacade.findClass(CommonClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE... | run |
72,230 | boolean (@NotNull final PsiMethodReferenceExpression expression, @NotNull final PsiMethod interfaceMethod, @NotNull final PsiElement element) { return element instanceof PsiClass && ((PsiClass)element).getConstructors().length == 0 && expression.isConstructor() && !interfaceMethod.hasParameters(); } | maybeDefaultConstructorRef |
72,231 | PsiType (@NotNull final PsiClass interface2Consider, @NotNull final PsiFunctionalExpression expression, @NotNull final PsiType[] left, @NotNull final PsiType[] right) { final Project project = interface2Consider.getProject(); final PsiSubstitutor substitutor = PsiResolveHelper.getInstance(project) .inferTypeArguments(i... | getAcceptableType |
72,232 | PsiSubstitutor (@NotNull final PsiMethodReferenceExpression expression, @NotNull final PsiMethod method) { final PsiType[] typeArguments = expression.getTypeParameters(); if (typeArguments.length > 0) { final PsiTypeParameter[] typeParameters = method.getTypeParameters(); if (typeParameters.length == typeArguments.leng... | getPartialSubstitutor |
72,233 | boolean (PsiMethodReferenceExpression expression, PsiMethod method) { return PsiMethodReferenceUtil.isStaticallyReferenced(expression) && !method.hasModifierProperty(PsiModifier.STATIC) && !method.isConstructor(); } | hasOffset |
72,234 | void (@NotNull IdeaPluginDescriptor pluginDescriptor) { updateDefaults(); } | pluginLoaded |
72,235 | void (@NotNull IdeaPluginDescriptor pluginDescriptor, boolean isUpdate) { updateDefaults(); } | pluginUnloaded |
72,236 | void () { myAnnotationSupports = AnnotationPackageSupport.EP_NAME.getExtensionList(); myDefaultNullables = StreamEx.of(myAnnotationSupports) .cross(s -> s.getNullabilityAnnotations(Nullability.NULLABLE).stream()).invert().toMap(); myDefaultNotNulls = StreamEx.of(myAnnotationSupports) .cross(s -> s.getNullabilityAnnotat... | updateDefaults |
72,237 | void (String @NotNull ... annotations) { myNotNulls.clear(); Collections.addAll(myNotNulls, annotations); normalizeDefaults(); } | setNotNulls |
72,238 | void (String @NotNull ... annotations) { myNullables.clear(); Collections.addAll(myNullables, annotations); normalizeDefaults(); } | setNullables |
72,239 | String () { return myDefaultNullable; } | getDefaultNullable |
72,240 | void (@NotNull String defaultNullable) { LOG.assertTrue(getNullables().contains(defaultNullable)); myDefaultNullable = defaultNullable; myTracker.incModificationCount(); } | setDefaultNullable |
72,241 | String () { return myDefaultNotNull; } | getDefaultNotNull |
72,242 | void (@NotNull String defaultNotNull) { LOG.assertTrue(getNotNulls().contains(defaultNotNull)); myDefaultNotNull = defaultNotNull; myTracker.incModificationCount(); } | setDefaultNotNull |
72,243 | Optional<Nullability> (String name) { if (myNotNulls.contains(name)) { return Optional.of(Nullability.NOT_NULL); } if (myNullables.contains(name)) { return Optional.of(Nullability.NULLABLE); } if (myDefaultUnknowns.containsKey(name)) { return Optional.of(Nullability.UNKNOWN); } return Optional.empty(); } | getAnnotationNullability |
72,244 | boolean (String name) { AnnotationPackageSupport support = findAnnotationSupport(name); return support != null && support.isTypeUseAnnotationLocationRestricted(); } | isTypeUseAnnotationLocationRestricted |
72,245 | boolean (String name) { AnnotationPackageSupport support = findAnnotationSupport(name); return support == null || support.canAnnotateLocals(); } | canAnnotateLocals |
72,246 | List<String> () { return Collections.unmodifiableList(myNullables); } | getNullables |
72,247 | List<String> () { return Collections.unmodifiableList(myNotNulls); } | getNotNulls |
72,248 | List<String> () { return Collections.unmodifiableList(myInstrumentedNotNulls); } | getInstrumentedNotNulls |
72,249 | void (@NotNull List<String> names) { myInstrumentedNotNulls = ContainerUtil.sorted(names); myTracker.incModificationCount(); } | setInstrumentedNotNulls |
72,250 | boolean (@NotNull PsiElement element) { return HardcodedContracts.hasHardcodedContracts(element); } | hasHardcodedContracts |
72,251 | Element () { Element component = new Element("component"); if (!hasDefaultValues()) { try { DefaultJDOMExternalizer.writeExternal(this, component); } catch (WriteExternalException e) { LOG.error(e); } } if (myInstrumentedNotNulls.size() != 1 || !NOT_NULL.equals(myInstrumentedNotNulls.get(0))) { // poor man's @XCollecti... | getState |
72,252 | boolean () { return NOT_NULL.equals(myDefaultNotNull) && NULLABLE.equals(myDefaultNullable) && new HashSet<>(myNullables).equals(myDefaultNullables.keySet()) && new HashSet<>(myNotNulls).equals(myDefaultNotNulls.keySet()); } | hasDefaultValues |
72,253 | void (@NotNull Element state) { try { DefaultJDOMExternalizer.readExternal(this, state); normalizeDefaults(); } catch (InvalidDataException e) { LOG.error(e); } Element instrumented = state.getChild(INSTRUMENTED_NOT_NULLS_TAG); if (instrumented == null) { myInstrumentedNotNulls = List.of(NOT_NULL); } else { myInstrumen... | loadState |
72,254 | void () { myNotNulls.removeAll(myDefaultNullables.keySet()); myNullables.removeAll(myDefaultNotNulls.keySet()); myNullables.addAll(ContainerUtil.filter(myDefaultNullables.keySet(), s -> !myNullables.contains(s))); myNotNulls.addAll(ContainerUtil.filter(myDefaultNotNulls.keySet(), s -> !myNotNulls.contains(s))); myTrack... | normalizeDefaults |
72,255 | List<PsiClass> () { if (!getNotNulls().contains(Jsr305Support.JAVAX_ANNOTATION_NONNULL)) { return Collections.emptyList(); } return CachedValuesManager.getManager(myProject).getCachedValue(myProject, () -> { Set<PsiClass> result = new HashSet<>(getPossiblyUnresolvedJavaNicknameUsages()); GlobalSearchScope scope = new D... | getAllNullabilityNickNames |
72,256 | boolean (@NotNull VirtualFile file) { return super.contains(file) && !FileTypeRegistry.getInstance().isFileOfType(file, JavaFileType.INSTANCE); } | contains |
72,257 | List<PsiClass> () { List<PsiClass> result = new ArrayList<>(); Collection<PsiAnnotation> annotations = JavaAnnotationIndex.getInstance().getAnnotations(StringUtil.getShortName( Jsr305Support.TYPE_QUALIFIER_NICKNAME), myProject, GlobalSearchScope.allScope(myProject)); for (PsiAnnotation annotation : annotations) { PsiEl... | getPossiblyUnresolvedJavaNicknameUsages |
72,258 | NullabilityAnnotationInfo (@NotNull PsiAnnotation annotation, @NotNull PsiElement context, PsiAnnotation.TargetType @NotNull [] placeTargetTypes, boolean superPackage) { for (AnnotationPackageSupport support : myAnnotationSupports) { NullabilityAnnotationInfo info = support.getNullabilityByContainerAnnotation(annotatio... | checkNullityDefault |
72,259 | List<String> (@NotNull Nullability nullability) { return ContainerUtil.mapNotNull(getAllNullabilityNickNames(), c -> Jsr305Support.getNickNamedNullability(c) == nullability ? c.getQualifiedName() : null); } | filterNickNames |
72,260 | List<String> () { return CachedValuesManager.getManager(myProject).getCachedValue(myProject, () -> CachedValueProvider.Result.create(StreamEx.of(getNullables(), filterNickNames(Nullability.NULLABLE)).toFlatList(Function.identity()), PsiModificationTracker.MODIFICATION_COUNT)); } | getNullablesWithNickNames |
72,261 | List<String> () { return CachedValuesManager.getManager(myProject).getCachedValue(myProject, () -> CachedValueProvider.Result.create(StreamEx.of(getNotNulls(), filterNickNames(Nullability.NOT_NULL)).toFlatList(Function.identity()), PsiModificationTracker.MODIFICATION_COUNT)); } | getNotNullsWithNickNames |
72,262 | NullabilityAnnotationDataHolder () { return CachedValuesManager.getManager(myProject).getCachedValue(myProject, () -> { Map<String, Nullability> result = new HashMap<>(); for (String qName : myDefaultAll) { result.put(qName, null); } for (String qName : getNotNulls()) { result.put(qName, Nullability.NOT_NULL); } for (S... | getAllNullabilityAnnotationsWithNickNames |
72,263 | Set<String> () { return result.keySet(); } | qualifiedNames |
72,264 | Nullability (@NotNull Nullability nullability, @NotNull PsiAnnotation annotation) { if (nullability == Nullability.NOT_NULL && annotation.hasQualifiedName(Jsr305Support.JAVAX_ANNOTATION_NONNULL)) { Nullability correctedNullability = Jsr305Support.extractNullityFromWhenValue(annotation); if (correctedNullability != null... | correctNullability |
72,265 | long () { return myTracker.getModificationCount(); } | getModificationCount |
72,266 | String () { return JavaBundle.message("intention.family.make.inferred.annotations.explicit"); } | getFamilyName |
72,267 | boolean (@NotNull Project project, Editor editor, PsiFile file) { final PsiElement leaf = file.findElementAt(editor.getCaretModel().getOffset()); if (leaf == null) return false; final PsiModifierListOwner owner = ObjectUtils.tryCast(leaf.getParent(), PsiModifierListOwner.class); return isAvailable(file, owner); } | isAvailable |
72,268 | boolean (PsiFile file, PsiModifierListOwner owner) { if (owner != null && owner.getLanguage().isKindOf(JavaLanguage.INSTANCE) && isWritable(owner) && ModuleUtilCore.findModuleForPsiElement(file) != null && PsiUtil.getLanguageLevel(file).isAtLeast(LanguageLevel.JDK_1_5)) { List<PsiAnnotation> annotations = getAnnotation... | isAvailable |
72,269 | List<PsiAnnotation> (PsiFile file, List<PsiAnnotation> annotations) { if (annotations.isEmpty() || !needToAddDependency(file, annotations)) return annotations; if (InferNullityAnnotationsAction.maySuggestAnnotationDependency(file.getProject())) { myNeedToAddDependency = true; return annotations; } return ContainerUtil.... | filterAnnotations |
72,270 | String (PsiAnnotation annotation) { final PsiJavaCodeReferenceElement nameRef = correctAnnotation(annotation).getNameReferenceElement(); final String name = nameRef != null ? nameRef.getReferenceName() : annotation.getQualifiedName(); return "@" + name + annotation.getParameterList().getText(); } | getAnnotationPresentation |
72,271 | boolean (PsiModifierListOwner owner) { if (owner instanceof PsiCompiledElement) return false; VirtualFile vFile = PsiUtilCore.getVirtualFile(owner); return vFile != null && vFile.isInLocalFileSystem(); } | isWritable |
72,272 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { PsiElement leaf = file.findElementAt(editor.getCaretModel().getOffset()); if (leaf == null) return IntentionPreviewInfo.EMPTY; PsiModifierListOwner owner = ObjectUtils.tryCast(leaf.getParent(), PsiModifierListOwner.class); ... | generatePreview |
72,273 | void (@NotNull Project project, PsiFile file, PsiModifierListOwner owner) { if (!FileModificationService.getInstance().preparePsiElementForWrite(owner)) return; final Module module = ModuleUtilCore.findModuleForPsiElement(file); assert module != null; // Inferred annotations are non-physical, so we can pass them betwee... | makeAnnotationsExplicit |
72,274 | boolean (PsiFile file, List<PsiAnnotation> annotations) { return ContainerUtil.exists(annotations, MakeInferredAnnotationExplicit::isJetBrainsAnnotation) && JavaPsiFacade.getInstance(file.getProject()).findClass(AnnotationUtil.NOT_NULL, file.getResolveScope()) == null; } | needToAddDependency |
72,275 | boolean (PsiAnnotation anno) { String qualifiedName = anno.getQualifiedName(); return qualifiedName != null && qualifiedName.startsWith("org.jetbrains.annotations."); } | isJetBrainsAnnotation |
72,276 | void (@NotNull Project project, @NotNull PsiFile file, @Nullable PsiModifierListOwner owner, @NotNull List<PsiAnnotation> annotations) { if (owner == null) return; WriteCommandAction.runWriteCommandAction(project, getFamilyName(), null, () -> DumbService.getInstance(project).withAlternativeResolveEnabled( () -> doMakeA... | doStartWriteAction |
72,277 | List<PsiAnnotation> (@NotNull PsiModifierListOwner owner) { List<PsiAnnotation> allAnnotations = StreamEx.of(InferredAnnotationsManager.getInstance(owner.getProject()).findInferredAnnotations(owner)) .remove(DefaultInferredAnnotationProvider::isExperimentalInferredAnnotation) .map(MakeInferredAnnotationExplicit::correc... | getAnnotationsToAdd |
72,278 | void (@NotNull Project project, @NotNull PsiModifierListOwner owner, @NotNull List<PsiAnnotation> annotations) { for (PsiAnnotation toInsert : annotations) { final String qname = toInsert.getQualifiedName(); assert qname != null; PsiAnnotationOwner target = AnnotationTargetUtil.getTarget(owner, qname); assert target !=... | doMakeAnnotationExplicit |
72,279 | PsiAnnotation (@NotNull PsiAnnotation annotation) { Project project = annotation.getProject(); NullableNotNullManager nnnm = NullableNotNullManager.getInstance(project); PsiAnnotation corrected = null; if (annotation.hasQualifiedName(AnnotationUtil.NULLABLE)) { corrected = createAnnotation(project, nnnm.getDefaultNulla... | correctAnnotation |
72,280 | PsiAnnotation (Project project, String qualifiedName) { JavaPsiFacade facade = JavaPsiFacade.getInstance(project); GlobalSearchScope allScope = GlobalSearchScope.allScope(project); if (facade.findClass(qualifiedName, allScope) != null) { return facade.getElementFactory().createAnnotationFromText("@" + qualifiedName, nu... | createAnnotation |
72,281 | boolean () { return !myNeedToAddDependency; } | startInWriteAction |
72,282 | int () { return NEW_AS_CONSTRUCTOR | THIS_ACCEPTED | SUPER_ACCEPTED; } | getAllAdditionalFlags |
72,283 | int () { return THIS_ACCEPTED | SUPER_ACCEPTED; } | getAdditionalDefinitionSearchFlags |
72,284 | int () { return NEW_AS_CONSTRUCTOR; } | getAdditionalReferenceSearchFlags |
72,285 | PsiElement (Editor editor, int offset, int flags, @NotNull PsiElement targetElement) { if (targetElement instanceof PsiKeyword) { if (targetElement.getParent() instanceof PsiThisExpression) { if (!BitUtil.isSet(flags, THIS_ACCEPTED)) return null; PsiType type = ((PsiThisExpression)targetElement.getParent()).getType(); ... | adjustTargetElement |
72,286 | boolean (@NotNull PsiElement parent) { return !(parent instanceof PsiDocTag) && !(parent instanceof PsiAnonymousClass); } | isAcceptableNamedParent |
72,287 | ThreeState (@NotNull final PsiElement element, final PsiElement referenceOrReferencedElement) { if (isEnumConstantReference(element, referenceOrReferencedElement)) return ThreeState.NO; return super.isAcceptableReferencedElement(element, referenceOrReferencedElement); } | isAcceptableReferencedElement |
72,288 | boolean (final PsiElement element, final PsiElement referenceOrReferencedElement) { return element != null && element.getParent() instanceof PsiEnumConstant && referenceOrReferencedElement instanceof PsiMethod && ((PsiMethod)referenceOrReferencedElement).isConstructor(); } | isEnumConstantReference |
72,289 | PsiElement (@NotNull PsiFile file, @NotNull Editor editor, int offset, int flags, @Nullable PsiElement refElement) { PsiReference ref = null; if (refElement == null) { ref = TargetElementUtil.findReference(editor, offset); if (ref instanceof PsiJavaReference) { refElement = ((PsiJavaReference)ref).advancedResolve(true)... | adjustReferenceOrReferencedElement |
72,290 | PsiElement (@NotNull PsiElement element) { if (element instanceof PsiIdentifier) { PsiElement parent = element.getParent(); if (parent instanceof PsiClass && element.equals(((PsiClass)parent).getNameIdentifier()) || parent instanceof PsiVariable && element.equals(((PsiVariable)parent).getNameIdentifier()) || parent ins... | getNamedElement |
72,291 | PsiReferenceExpression (Editor editor) { final PsiReference ref = TargetElementUtil.findReference(editor); return ref instanceof PsiReferenceExpression ? (PsiReferenceExpression)ref : null; } | findReferenceExpression |
72,292 | PsiElement (@NotNull final PsiReference ref) { final PsiElement parent = ref.getElement().getParent(); if (parent instanceof PsiMethodCallExpression) return parent; return super.adjustReference(ref); } | adjustReference |
72,293 | PsiElement (Editor editor, int flags, @Nullable PsiElement element, @Nullable PsiElement contextElement) { if (element instanceof PsiAnonymousClass) { return ((PsiAnonymousClass)element).getBaseClassType().resolve(); } return element; } | adjustElement |
72,294 | Collection<PsiElement> (@NotNull PsiReference reference) { PsiElement parent = reference.getElement().getParent(); if (parent instanceof PsiMethodCallExpression || parent instanceof PsiNewExpression && !((PsiNewExpression)parent).isArrayCreation()) { PsiCallExpression callExpr = (PsiCallExpression)parent; boolean allow... | getTargetCandidates |
72,295 | PsiElement (@NotNull final PsiElement element, @Nullable final PsiElement navElement) { if (navElement == element && element instanceof PsiCompiledElement && element instanceof PsiMethod method && method.isConstructor() && method.getParameterList().isEmpty()) { PsiClass aClass = method.getContainingClass(); PsiElement ... | getGotoDeclarationTarget |
72,296 | boolean (@NotNull final PsiElement element) { if (element instanceof PsiModifierListOwner && ((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.ABSTRACT)) { return false; } return super.includeSelfInGotoImplementation(element); } | includeSelfInGotoImplementation |
72,297 | boolean (@Nullable PsiReference reference, @NotNull PsiElement element) { if (reference instanceof PsiReferenceExpression && element instanceof PsiMember) { return getClassesWithMember(reference, (PsiMember)element) != null; } return super.acceptImplementationForReference(reference, element); } | acceptImplementationForReference |
72,298 | PsiClass[] () { PsiClass containingClass = member.getContainingClass(); final PsiExpression expression = ((PsiReferenceExpression)reference).getQualifierExpression(); PsiClass psiClass; if (reference instanceof PsiMethodReferenceExpression) { psiClass = PsiMethodReferenceUtil.getQualifierResolveResult((PsiMethodReferen... | compute |
72,299 | PsiClass[] (PsiClass containingClass, PsiClass psiClass, Set<? super PsiClass> visited) { if (psiClass instanceof PsiTypeParameter) { List<PsiClass> result = new ArrayList<>(); for (PsiClassType classType : psiClass.getExtendsListTypes()) { PsiClass aClass = classType.resolve(); if (aClass != null && visited.add(aClass... | getInheritors |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.