Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
75,800 | boolean () { PsiClass target = myTargetMethod.getContainingClass(); LOG.assertTrue(target != null); PsiMethod[] methods = target.findMethodsByName(myTargetMethod.getName(), false); for (PsiMethod method : methods) { if (PsiUtil.isApplicable(method, PsiSubstitutor.EMPTY, myExpressions)) return true; } return false; } | isMethodSignatureExists |
75,801 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { HashSet<ParameterInfoImpl> newParams = new HashSet<>(); HashSet<ParameterInfoImpl> removedParams = new HashSet<>(); HashSet<ParameterInfoImpl> changedParams = new HashSet<>(); if (!(myTargetMethod.getContainingFile() instan... | generatePreview |
75,802 | void (@NotNull final Project project, Editor editor, final PsiFile file) { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; final PsiMethod method = SuperMethodWarningUtil.checkSuperMethod(myTargetMethod); if (method == null) return; myNewParametersInfo = getNewParametersInfo(myExpressions,... | invoke |
75,803 | List<ParameterInfoImpl> (@NotNull Project project, final Editor editor, final PsiFile file, @NotNull PsiMethod method, final int minUsagesNumber, final ParameterInfoImpl[] newParametersInfo, final boolean changeAllUsages, final boolean allowDelegation, @Nullable final Consumer<? super List<ParameterInfo>> callback) { i... | performChange |
75,804 | String (int oldIndex, final ParameterInfoImpl[] parametersInfo) { if (parametersInfo == null) return null; for (ParameterInfoImpl info : parametersInfo) { if (info.oldParameterIndex == oldIndex) { return info.getName(); } } return null; } | getNewParameterNameByOldIndex |
75,805 | PsiType (PsiParameter parameter, PsiMethod targetMethod) { PsiType bareParamType = parameter.getType(); if (!bareParamType.isValid()) { try { PsiUtil.ensureValidType(bareParamType); } catch (ProcessCanceledException e) { throw e; } catch (Throwable e) { throw PluginException.createByClass( parameter.getClass() + "; val... | getValidParameterType |
75,806 | String (@NotNull PsiType exprType) { return StringUtil.escapeXmlEntities(exprType.getPresentableText()); } | escapePresentableType |
75,807 | boolean (PsiExpression[] expressions, PsiMethod targetMethod, PsiSubstitutor substitutor, StringBuilder buf, HashSet<? super ParameterInfoImpl> newParams, PsiParameter[] parameters, List<? super ParameterInfoImpl> result) { // find which parameters to introduce and where Set<String> existingNames = new HashSet<>(); for... | findNewParamsPlace |
75,808 | boolean (PsiExpression[] expressions, int ei, PsiParameter varargParam, PsiSubstitutor substitutor) { if (varargParam == null) return false; final PsiExpression expression = expressions[ei]; if (expression == null || TypeConversionUtil.areTypesAssignmentCompatible(substitutor.substitute(((PsiEllipsisType)varargParam.ge... | isArgumentInVarargPosition |
75,809 | String (JavaCodeStyleManager codeStyleManager, PsiExpression expression, PsiType exprType, Set<? super String> existingNames) { SuggestedNameInfo nameInfo = codeStyleManager.suggestVariableName(VariableKind.PARAMETER, null, expression, exprType); @NonNls String[] names = nameInfo.names; if (expression instanceof PsiRef... | suggestUniqueParameterName |
75,810 | boolean () { return false; } | startInWriteAction |
75,811 | RenameToIgnoredFix (@NotNull PsiNamedElement element, boolean useElementNameAsSuffix) { if (element instanceof PsiVariable variable && canBeUnnamed(variable) && !VariableAccessUtils.variableIsUsed(variable, PsiUtil.getVariableCodeBlock(variable, null))) { return new RenameToIgnoredFix(variable, "_"); } String baseName ... | createRenameToIgnoreFix |
75,812 | boolean (PsiVariable variable) { if (!HighlightingFeature.UNNAMED_PATTERNS_AND_VARIABLES.isAvailable(variable)) return false; if (variable instanceof PsiPatternVariable || variable instanceof PsiResourceVariable) return true; if (variable instanceof PsiLocalVariable) { return variable.getParent() instanceof PsiDeclarat... | canBeUnnamed |
75,813 | Presentation (@NotNull ActionContext context, @NotNull PsiAnnotation element) { return Presentation.of(myMissedElements.size() == 1 ? QuickFixBundle.message("add.missing.annotation.single.parameter.fix", ContainerUtil.getFirstItem(myMissedElements)) : QuickFixBundle.message("add.missing.annotation.parameters.fix", Stri... | getPresentation |
75,814 | String () { return QuickFixBundle.message("annotations.fix"); } | getFamilyName |
75,815 | void (@NotNull ActionContext context, @NotNull PsiAnnotation annotation, @NotNull ModPsiUpdater updater) { final PsiNameValuePair[] addedParameters = annotation.getParameterList().getAttributes(); final Object2IntMap<String> annotationsOrderMap = getAnnotationsOrderMap(); final SortedSet<Pair<String, PsiAnnotationMembe... | invoke |
75,816 | Object2IntMap<String> () { final Object2IntMap<String> map = new Object2IntOpenHashMap<>(); for (int i = 0; i < myAnnotationMethods.length; i++) { map.put(myAnnotationMethods[i].getName(), i); } return map; } | getAnnotationsOrderMap |
75,817 | boolean (final Object2IntMap<String> orderMap, final PsiNameValuePair[] addedParameters) { if (addedParameters.length <= 1) { return true; } int previousOrder = orderMap.getInt(addedParameters[0].getName()); for (int i = 1; i < addedParameters.length; i++) { final int currentOrder = orderMap.getInt(addedParameters[i].g... | isAlreadyAddedOrdered |
75,818 | SetupJDKFix () { return ourInstance; } | getInstance |
75,819 | String () { return QuickFixBundle.message("setup.jdk.location.text"); } | getText |
75,820 | String () { return QuickFixBundle.message("setup.jdk.location.family"); } | getFamilyName |
75,821 | boolean (@NotNull Project project, Editor editor, PsiFile file) { return JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_OBJECT, file.getResolveScope()) == null; } | isAvailable |
75,822 | void (@NotNull Project project, Editor editor, final PsiFile file) { SdkPopupFactory .newBuilder() .withProject(project) .withSdkTypeFilter(type -> type instanceof JavaSdkType) .updateSdkForFile(file) .buildPopup() .showInBestPositionFor(editor); } | invoke |
75,823 | boolean () { return false; } | startInWriteAction |
75,824 | String () { return QuickFixBundle.message("implement.or.extend.fix.family"); } | getFamilyName |
75,825 | ModCommand (@NotNull ActionContext context, @NotNull PsiClass subclass) { PsiClass parentClass = myParentClassPointer.getElement(); if (parentClass == null) return ModCommand.nop(); boolean parentIsInterface = parentClass.isInterface(); boolean subclassIsInterface = subclass.isInterface(); if (!parentIsInterface && sub... | perform |
75,826 | boolean (PsiClass psiClass) { PsiModifierList modifiers = psiClass.getModifierList(); if (modifiers == null) return false; return hasSealedClassSubclassModifier(modifiers); } | hasSealedClassSubclassModifier |
75,827 | boolean (@NotNull PsiModifierList modifiers) { return modifiers.hasExplicitModifier(PsiModifier.FINAL) || modifiers.hasExplicitModifier(PsiModifier.SEALED) || modifiers.hasExplicitModifier(PsiModifier.NON_SEALED); } | hasSealedClassSubclassModifier |
75,828 | void (@NotNull ActionContext context, @NotNull PsiClass subclass, @NotNull ModPsiUpdater updater) { PsiClass parentClass = myParentClassPointer.getElement(); if (parentClass == null || !parentClass.hasModifierProperty(PsiModifier.SEALED)) return; if (ImplementOrExtendFix.implementOrExtend(parentClass, subclass) == null... | invoke |
75,829 | PsiTypeElement (@NotNull PsiTypeElement typeElement, ExpectedTypeInfo @NotNull [] infos, @Nullable PsiElement context, @NotNull PsiClass targetClass) { LOG.assertTrue(typeElement.isValid()); if (typeElement.isPhysical()) { ApplicationManager.getApplication().assertWriteAccessAllowed(); } GlobalSearchScope scope = typeE... | setupTypeElement |
75,830 | PsiTypeElement (@NotNull PsiTypeElement templateElement, @NotNull PsiType type) { PsiTypeElement newTypeElement = JavaPsiFacade.getElementFactory(myProject).createTypeElement(type); return PostprocessReformattingAspect.getInstance(myProject).disablePostprocessFormattingInside( () -> (PsiTypeElement)templateElement.repl... | replaceTypeElement |
75,831 | PsiSubstitutor (Project project, PsiElement context, PsiClass targetClass) { if (context == null || targetClass == null) return PsiSubstitutor.EMPTY; PsiTypeParameterListOwner currContext = PsiTreeUtil.getParentOfType(context, PsiTypeParameterListOwner.class); PsiManager manager = context.getManager(); PsiSubstitutor s... | getRawingSubstitutor |
75,832 | PsiClassType (PsiType type) { type = type.getDeepComponentType(); if (type instanceof PsiClassType) return (PsiClassType)type; return null; } | getComponentType |
75,833 | int (PsiTypeElement typeElement, PsiType expectedType, PsiSubstitutor rawingSubstitutor, boolean toplevel) { final List<PsiTypeParameter> matchedParameters = matchingTypeParameters(mySubstitutor, expectedType, TYPE_STRICTLY); if (!matchedParameters.isEmpty()) { List<PsiType> types = new SmartList<>(map(matchedParameter... | substituteToTypeParameters |
75,834 | PsiType (@NotNull PsiType type) { if (type.equals(PsiTypes.nullType())) return PsiType.getJavaLangObject(myManager, myResolveScope); return type; } | visitType |
75,835 | PsiType (@NotNull PsiCapturedWildcardType capturedWildcardType) { return capturedWildcardType.getUpperBound().accept(this); } | visitCapturedWildcardType |
75,836 | List<PsiTypeParameter> (@NotNull PsiSubstitutor substitutor, @NotNull PsiType expectedType, @Type int kind) { final List<PsiTypeParameter> result = new SmartList<>(); for (Map.Entry<PsiTypeParameter, PsiType> entry : substitutor.getSubstitutionMap().entrySet()) { final PsiType typeArgument = entry.getValue(); if (typeA... | matchingTypeParameters |
75,837 | boolean (@NotNull PsiType type, @NotNull PsiType expectedType, @Type int kind) { return switch (kind) { case TYPE_STRICTLY -> type.equals(expectedType); case TYPE_OR_SUBTYPE -> expectedType.isAssignableFrom(type); case TYPE_OR_SUPERTYPE -> type.isAssignableFrom(expectedType); default -> false; }; } | matches |
75,838 | boolean (@NotNull PsiSubstitutor substitutor) { return substitutor.getSubstitutionMap().containsValue(null); } | hasNullSubstitutions |
75,839 | Template (PsiField field, Object expectedTypes, PsiClass targetClass, Editor editor, PsiElement context, boolean createConstantField, @NotNull PsiSubstitutor substitutor) { Project project = field.getProject(); PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); field = CodeInsightUtilCore.forcePsiPos... | setupTemplateImpl |
75,840 | boolean (Project project, ExpectedTypeInfo[] expectedTypes) { if (Registry.is("ide.create.field.enable.shortening")) return false; return ExpectedTypesProvider.processExpectedTypes(expectedTypes, new PsiTypeVisitor<>() { @Override public PsiType visitType(@NotNull PsiType type) { return type; } }, project).length > 1; ... | disableShortenLongNames |
75,841 | PsiType (@NotNull PsiType type) { return type; } | visitType |
75,842 | PsiField (@NotNull PsiClass targetClass, @NotNull PsiField field, @Nullable PsiElement place) { PsiMember enclosingContext = null; PsiClass parentClass; do { enclosingContext = PsiTreeUtil.getParentOfType(enclosingContext == null ? place : enclosingContext, PsiMethod.class, PsiField.class, PsiClassInitializer.class); p... | insertFieldImpl |
75,843 | String (@NotNull PsiJavaCodeReferenceElement reference) { return reference.getReferenceName(); } | getReferenceName |
75,844 | PsiElement (@NotNull PsiJavaCodeReferenceElement reference) { return reference.getReferenceNameElement(); } | getReferenceNameElement |
75,845 | void (@NotNull PsiReference ref, @NotNull PsiClass targetClass) { if (ref instanceof PsiImportStaticReferenceElement) { ((PsiImportStaticReferenceElement)ref).bindToTargetClass(targetClass); } else { super.bindReference(ref, targetClass); } } | bindReference |
75,846 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { List<? extends PsiClass> classesToImport = getClassesToImport(true); if (classesToImport.isEmpty()) return IntentionPreviewInfo.EMPTY; PsiClass firstClassToImport = classesToImport.get(0); PsiJavaCodeReferenceElement ref = ... | generatePreview |
75,847 | boolean (@NotNull PsiJavaCodeReferenceElement reference) { PsiReferenceParameterList refParameters = reference.getParameterList(); return refParameters != null && refParameters.getTypeParameterElements().length > 0; } | hasTypeParameters |
75,848 | String (@NotNull PsiJavaCodeReferenceElement referenceElement) { return referenceElement.getQualifiedName(); } | getQualifiedName |
75,849 | boolean (@NotNull PsiJavaCodeReferenceElement reference) { return reference.isQualified(); } | isQualified |
75,850 | boolean (@NotNull PsiFile psiFile, @NotNull String name) { if (!(psiFile instanceof PsiJavaFile)) return false; PsiImportList importList = ((PsiJavaFile)psiFile).getImportList(); if (importList == null) return false; PsiImportStatement[] importStatements = importList.getImportStatements(); for (PsiImportStatement impor... | hasUnresolvedImportWhichCanImport |
75,851 | String (@NotNull PsiJavaCodeReferenceElement referenceElement) { PsiElement parent = referenceElement.getParent(); if (parent instanceof PsiJavaCodeReferenceElement) { return ((PsiJavaCodeReferenceElement)parent).getReferenceName(); } return super.getRequiredMemberName(referenceElement); } | getRequiredMemberName |
75,852 | boolean (@NotNull PsiJavaCodeReferenceElement ref) { if (PsiTreeUtil.getParentOfType(ref, PsiImportStatementBase.class) != null) return false; if (ref instanceof PsiReferenceExpression) { PsiElement parent = ref.getParent(); return parent instanceof PsiReferenceExpression || parent instanceof PsiExpressionStatement; } ... | canReferenceClass |
75,853 | boolean (@NotNull PsiJavaCodeReferenceElement element) { PsiTypeElement type = SyntaxTraverser.psiApi().parents(element).filter(PsiTypeElement.class).last(); PsiElement prev = FilterPositionUtil.searchNonSpaceNonCommentBack(type); PsiTypeParameterList typeParameterList = PsiTreeUtil.getParentOfType(prev, PsiTypeParamet... | inReturnTypeOfIncompleteGenericMethod |
75,854 | Collection<PsiClass> (@NotNull Collection<PsiClass> candidates, @NotNull PsiJavaCodeReferenceElement referenceElement) { if (referenceElement instanceof PsiReferenceExpression) { return Collections.emptyList(); } PsiElement typeElement = referenceElement.getParent(); if (typeElement instanceof PsiTypeElement) { PsiElem... | filterByContext |
75,855 | boolean (@NotNull PsiMember member, @NotNull PsiJavaCodeReferenceElement referenceElement) { return PsiUtil.isAccessible(member, referenceElement, null); } | isAccessible |
75,856 | boolean (@NotNull PsiFile containingFile, @NotNull PsiClass classToImport) { if (containingFile instanceof PsiJavaFile) { PsiImportList importList = ((PsiJavaFile)containingFile).getImportList(); if (importList == null) return false; boolean result = false; String classQualifiedName = classToImport.getQualifiedName(); ... | isClassMaybeImportedAlready |
75,857 | String () { return "ImportClassFix: "+getReference()+" -> "+getClassesToImport(); } | toString |
75,858 | String () { @NonNls final String what; if (myCreateGetter && myCreateSetter) { what = "create.getter.and.setter.for.field"; } else if (myCreateGetter) { what = "create.getter.for.field"; } else if (myCreateSetter) { what = "create.setter.for.field"; } else { throw new IllegalStateException("Either createGetter or creat... | getText |
75,859 | String () { return QuickFixBundle.message("create.accessor.for.unused.field.family"); } | getFamilyName |
75,860 | boolean (@NotNull Project project, Editor editor, PsiFile file) { if (!myField.isValid()) return false; final PsiClass aClass = myField.getContainingClass(); if (aClass == null) { return false; } if (myCreateGetter){ if (isStaticFinal(myField) || PropertyUtilBase.findPropertyGetter(aClass, myPropertyName, isStatic(myFi... | isAvailable |
75,861 | boolean (@NotNull PsiField field) { return field.hasModifierProperty(PsiModifier.FINAL); } | isFinal |
75,862 | boolean (@NotNull PsiField field) { return field.hasModifierProperty(PsiModifier.STATIC); } | isStatic |
75,863 | boolean (@NotNull PsiField field) { return isStatic(field) && isFinal(field); } | isStaticFinal |
75,864 | PsiElement (@NotNull PsiFile currentFile) { return myField; } | getElementToMakeWritable |
75,865 | boolean () { return true; } | startInWriteAction |
75,866 | String () { return QuickFixBundle.message("move.class.in.extend.list.family"); } | getFamilyName |
75,867 | void (@NotNull ActionContext context, @NotNull PsiTypeParameter typeParameter, @NotNull ModPsiUpdater updater) { PsiReferenceList extendsList = typeParameter.getExtendsList(); if (!(myTypePointer.getType() instanceof PsiClassType classType)) return; ExtendsListFix.modifyList(extendsList, false, -1, classType); ExtendsL... | invoke |
75,868 | void (@NotNull PsiJavaCodeReferenceElement ref, @NotNull QuickFixActionRegistrar registrar) { PsiFile containingFile = ref.getContainingFile(); if (containingFile instanceof PsiJavaCodeReferenceCodeFragment fragment && !fragment.isClassesAccepted()) { return; } List<IntentionAction> fixes = new ArrayList<>(); OrderEntr... | registerFixes |
75,869 | Collection<IntentionAction> (@NotNull PsiJavaCodeReferenceElement ref) { Collection<IntentionAction> result = new ArrayList<>(); PsiElement refParent = ref.getParent(); if (refParent != null && refParent.getParent() instanceof PsiDeconstructionPattern) { result.add(new CreateClassFromUsageFix(ref, CreateClassKind.RECOR... | createClassActions |
75,870 | Collection<IntentionAction> (@NotNull PsiReferenceExpression refExpr) { Collection<IntentionAction> result = new ArrayList<>(); boolean isQualified = refExpr.isQualified(); VariableKind kind = getKind(refExpr); if (!isQualified) { IntentionAction createLocalFix = new CreateLocalFromUsageFix(refExpr); result.add(kind ==... | createVariableActions |
75,871 | VariableKind (@NotNull PsiReferenceExpression refExpr) { JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(refExpr.getProject()); String reference = refExpr.getText(); if (StringUtil.isUpperCase(reference)) { return VariableKind.STATIC_FINAL_FIELD; } for (VariableKind kind : VariableKind.values()) { ... | getKind |
75,872 | Class<PsiJavaCodeReferenceElement> () { return PsiJavaCodeReferenceElement.class; } | getReferenceClass |
75,873 | String () { return QuickFixBundle.message("add.new.array.family"); } | getFamilyName |
75,874 | void (@NotNull ActionContext context, @NotNull PsiArrayInitializerExpression initializer, @NotNull ModPsiUpdater updater) { if (myType == null) return; doFix(myType, initializer); } | invoke |
75,875 | void (@NotNull PsiArrayInitializerExpression initializer) { PsiType type = getType(initializer); if (type == null) return; doFix(type, initializer); } | doFix |
75,876 | void (@NotNull PsiType type, @NotNull PsiArrayInitializerExpression initializer) { Project project = initializer.getProject(); PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); @NonNls String text = "new " + type.getCanonicalText() + "[]{}"; PsiNewExpression newExpr = (PsiNewExpression) factory.crea... | doFix |
75,877 | PsiType (@NotNull PsiArrayInitializerExpression initializer) { final PsiExpression[] initializers = initializer.getInitializers(); final PsiElement parent = initializer.getParent(); if (!(parent instanceof PsiAssignmentExpression assignmentExpression)) { if (initializers.length == 0) return null; return validateType(in... | getType |
75,878 | PsiType (PsiType type, @NotNull PsiElement context) { if (PsiTypes.nullType().equals(type)) return null; return LambdaUtil.notInferredType(type) || !PsiTypesUtil.isDenotableType(type, context) ? null : TypeConversionUtil.erasure(type); } | validateType |
75,879 | String () { return QuickFixBundle.message("change.parameter.class.family"); } | getFamilyName |
75,880 | boolean (@NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { PsiClass classToExtendFrom = myClassToExtendFromPointer != null ? myClassToExtendFromPointer.getElement() : null; return super.isAvailable(project, file, startElement, endElement) && classToExte... | isAvailable |
75,881 | void (@NotNull Project project, @NotNull PsiFile file, @Nullable Editor editor, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { final PsiClass myClass = (PsiClass)startElement; if (!FileModificationService.getInstance().prepareFileForWrite(startElement.getContainingFile())) return; ApplicationManage... | invoke |
75,882 | boolean () { return false; } | startInWriteAction |
75,883 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { PsiClass aClass = (PsiClass)getStartElement(); PsiFile fileCopy = (PsiFile)aClass.getContainingFile().copy(); PsiClass classCopy = PsiTreeUtil.findSameElementInCopy(aClass, fileCopy); invokeImpl(classCopy); Collection<Candi... | generatePreview |
75,884 | void (@NotNull ActionContext context, @NotNull PsiExpression expression, @NotNull ModPsiUpdater updater) { CommentTracker tracker = new CommentTracker(); tracker.replaceAndRestoreComments(expression.getParent(), "return " + tracker.text(expression) + ";"); } | invoke |
75,885 | String () { return CommonQuickFixBundle.message("fix.insert.x", PsiKeyword.RETURN); } | getFamilyName |
75,886 | ModCommand (@NotNull ActionContext ctx, @NotNull PsiElement element) { Context context = Context.from(element); if (context == null) return ModCommand.nop(); List<? extends PsiClassType> unhandledExceptions = context.myExceptions; List<? extends PsiCatchSection> catches = context.myCatches; List<@NotNull ModCommandActi... | perform |
75,887 | List<PsiCatchSection> (List<? extends PsiCatchSection> sections, @NotNull List<? extends PsiClassType> exceptionTypes, boolean isJava7OrHigher) { List<PsiCatchSection> finalSections = new ArrayList<>(); for (PsiCatchSection section : ContainerUtil.reverse(sections)) { finalSections.add(section); PsiType sectionType = s... | findSuitableSections |
75,888 | void (@NotNull List<? extends PsiClassType> exceptionsToAdd, @NotNull PsiCatchSection catchSection, Project project) { if (!catchSection.isValid() || !ContainerUtil.and(exceptionsToAdd, type -> type.isValid())) return; PsiParameter parameter = catchSection.getParameter(); if (parameter == null) return; PsiTypeElement t... | addTypeToCatch |
75,889 | String (@NotNull List<? extends PsiClassType> exceptionsToAdd, PsiType parameterType) { ArrayList<PsiType> types = new ArrayList<>(); types.add(parameterType); types.addAll(exceptionsToAdd); return PsiDisjunctionType.flattenAndRemoveDuplicates(types) .stream() .map(type -> type.getCanonicalText()) .collect(Collectors.j... | getTypeText |
75,890 | String () { return QuickFixBundle.message("add.exception.to.existing.catch.family"); } | getFamilyName |
75,891 | Context (@NotNull PsiElement element) { if (!element.isValid() || element instanceof PsiMethodReferenceExpression) return null; boolean isJava7OrHigher = PsiUtil.isLanguageLevel7OrHigher(element); List<PsiClassType> unhandledExceptions = new ArrayList<>(ExceptionUtil.getOwnUnhandledExceptions(element)); if (unhandledEx... | from |
75,892 | List<PsiTryStatement> (@NotNull PsiElement element) { PsiElement current = element; PsiElement parent = element.getParent(); List<PsiTryStatement> parents = new SmartList<>(); while (parent != null) { if (parent instanceof PsiLambdaExpression || parent instanceof PsiMember || parent instanceof PsiFile) break; if (paren... | getTryStatements |
75,893 | boolean (@NotNull PsiClassType newException, @NotNull PsiType catchType) { if (catchType instanceof PsiDisjunctionType disjunction) { for (PsiType type : disjunction.getDisjunctions()) { if (newException.isAssignableFrom(type)) { return true; } } return false; } return newException.isAssignableFrom(catchType); } | replacementNeeded |
75,894 | String () { return QuickFixBundle.message("static.import.method.text"); } | getBaseText |
75,895 | String (@NotNull PsiMethod method) { return PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_FQ_NAME, 0); } | getMemberPresentableText |
75,896 | String () { return QuickFixBundle.message("static.import.method.kind.text"); } | getMemberKindPresentableText |
75,897 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { return generatePreview(file, (__, method) -> AddSingleMemberStaticImportAction.bindAllClassRefs(file, method, method.getName(), method.getContainingClass())); } | generatePreview |
75,898 | QuestionAction (@NotNull List<? extends PsiMethod> methodsToImport, @NotNull Project project, Editor editor) { return new StaticImportMemberQuestionAction<>(project, editor, methodsToImport, myReferencePointer); } | createQuestionAction |
75,899 | PsiElement () { PsiMethodCallExpression element = myReferencePointer.getElement(); return element != null ? element.getMethodExpression().getQualifierExpression() : null; } | getQualifierExpression |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.