Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
76,100 | String () { return QuickFixBundle.message("remove.parameter.list"); } | getFamilyName |
76,101 | void (@NotNull ActionContext context, @NotNull PsiMethod method, @NotNull ModPsiUpdater updater) { final PsiMethod emptyMethod = JavaPsiFacade.getElementFactory(context.project()).createMethodFromText("void foo(){}", method); method.getParameterList().replace(emptyMethod.getParameterList()); } | invoke |
76,102 | MembersToImport<T> () { final List<Pair<T, ApplicableType>> list = new ArrayList<>(); final List<T> applicableList = new ArrayList<>(); for (Map.Entry<PsiClass, Collection<T>> methodEntry : mySuggestions.entrySet()) { registerMember(methodEntry.getKey(), methodEntry.getValue(), list, applicableList); } Comparator<T> co... | getMembersToImport |
76,103 | ApplicableType (@NotNull PsiType fieldType) { ExpectedTypeInfo[] expectedTypes = getExpectedTypes(); for (ExpectedTypeInfo info : expectedTypes) { if (TypeConversionUtil.isAssignable(info.getType(), fieldType)) return ApplicableType.APPLICABLE; if (info.getType() instanceof PsiClassType classType && classType.getParame... | isApplicableFor |
76,104 | boolean (T member) { ProgressManager.checkCanceled(); if (isExcluded(member)) { return true; } final PsiClass containingClass = member.getContainingClass(); if (containingClass != null) { final String qualifiedName = containingClass.getQualifiedName(); final PsiFile containingFile = myPlace.getContainingFile(); if (qua... | process |
76,105 | boolean (@NotNull PsiMember method) { String name = PsiUtil.getMemberQualifiedName(method); return name != null && JavaProjectCodeInsightSettings.getSettings(method.getProject()).isExcluded(name); } | isExcluded |
76,106 | void (@NotNull PsiClass containingClass, @NotNull Collection<? extends T> members, @NotNull List<Pair<T, ApplicableType>> list, @NotNull List<T> applicableList) { String qualifiedName = containingClass.getQualifiedName(); if (qualifiedName == null) { return; } Boolean alreadyMentioned = myPossibleClasses.get(qualifiedN... | registerMember |
76,107 | String () { PsiClass myTargetClass = (PsiClass)getStartElement(); String signature = myTargetClass == null ? "" : PsiFormatUtil.formatMethod(createMethod(myTargetClass), PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_PARAMETERS | PsiFormatUtilBase.SHOW_RAW_TYPE,... | getText |
76,108 | String () { return QuickFixBundle.message("create.method.from.usage.family"); } | getFamilyName |
76,109 | void (@NotNull Project project, @NotNull PsiFile file, @Nullable Editor editor, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { PsiClass myTargetClass = (PsiClass)startElement; PsiMethod method = createMethod(myTargetClass); List<Pair<PsiExpression, PsiType>> arguments = ContainerUtil.map(method.get... | invoke |
76,110 | PsiMethod (@NotNull PsiClass myTargetClass) { Project project = myTargetClass.getProject(); JVMElementFactory elementFactory = JVMElementFactories.getFactory(myTargetClass.getLanguage(), project); if (elementFactory == null) { elementFactory = JavaPsiFacade.getElementFactory(project); } String methodText = mySignature ... | createMethod |
76,111 | CreateMethodQuickFix (@NotNull PsiClass targetClass, @NonNls final String signature, @NonNls final String body) { CreateMethodQuickFix fix = new CreateMethodQuickFix(targetClass, signature, body); try { fix.createMethod(targetClass); return fix; } catch (IncorrectOperationException e) { return null; } } | createFix |
76,112 | String () { return JavaBundle.message("quickfix.add.variable.family.name"); } | getFamilyName |
76,113 | void (@NotNull ActionContext context, @NotNull PsiVariable variable, @NotNull ModPsiUpdater updater) { final LookupElement[] suggestedInitializers = suggestInitializer(variable); LOG.assertTrue(suggestedInitializers.length > 0); LookupElement firstLookupElement = suggestedInitializers[0]; LOG.assertTrue(firstLookupElem... | invoke |
76,114 | String () { return QuickFixBundle.message("add.return.statement.text"); } | getFamilyName |
76,115 | void (@NotNull ActionContext context, @NotNull PsiParameterListOwner method, @NotNull ModPsiUpdater updater) { if (invokeSingleExpressionLambdaFix(method)) { return; } String value = suggestReturnValue(method); PsiElementFactory factory = JavaPsiFacade.getElementFactory(context.project()); PsiReturnStatement returnStat... | invoke |
76,116 | String (@NotNull PsiParameterListOwner owner) { PsiType type; if (owner instanceof PsiMethod method) { type = method.getReturnType(); } else if (owner instanceof PsiLambdaExpression lambda) { type = LambdaUtil.getFunctionalInterfaceReturnType(lambda); } else { return PsiKeyword.NULL; // normally shouldn't happen } // f... | suggestReturnValue |
76,117 | String (@NotNull PsiParameterListOwner method, @NotNull PsiVariable variable, @Nullable PsiType type, boolean preciseTypeRequired) { PsiType varType = variable.getType(); if (!(type instanceof PsiArrayType arrayType)) return null; PsiType arrayComponentType = arrayType.getComponentType(); if (!(arrayComponentType insta... | getConversionToType |
76,118 | List<PsiVariable> (PsiParameterListOwner method) { List<PsiVariable> variables = new ArrayList<>(); PsiCodeBlock body = ObjectUtils.tryCast(method.getBody(), PsiCodeBlock.class); if (body != null) { PsiStatement[] statements = body.getStatements(); for (PsiStatement statement : statements) { if (statement instanceof Ps... | getDeclaredVariables |
76,119 | boolean (@NotNull PsiParameterListOwner method) { if (!(method instanceof PsiLambdaExpression lambda)) return false; PsiType returnType = LambdaUtil.getFunctionalInterfaceReturnType(lambda); if (returnType == null) return false; PsiCodeBlock body = ObjectUtils.tryCast(lambda.getBody(), PsiCodeBlock.class); if (body == ... | invokeSingleExpressionLambdaFix |
76,120 | String () { return QuickFixBundle.message("create.block"); } | getFamilyName |
76,121 | void (@NotNull ActionContext context, @NotNull PsiSwitchLabeledRuleStatement ruleStatement, @NotNull ModPsiUpdater updater) { if (!ruleStatement.isValid()) return; PsiCodeBlock parent = ObjectUtils.tryCast(ruleStatement.getParent(), PsiCodeBlock.class); if (parent == null) return; PsiJavaToken rBrace = parent.getRBrace... | invoke |
76,122 | boolean (int offset) { final PsiMethodReferenceExpression call = getMethodReference(); if (call == null || !call.isValid()) return false; final PsiType functionalInterfaceType = getFunctionalExpressionType(call); if (functionalInterfaceType == null || LambdaUtil.getFunctionalInterfaceMethod(functionalInterfaceType) == ... | isAvailableImpl |
76,123 | PsiType (PsiMethodReferenceExpression ref) { PsiType functionalInterfaceType = ref.getFunctionalInterfaceType(); if (functionalInterfaceType != null) return functionalInterfaceType; Ref<PsiType> type = new Ref<>(); if (LambdaUtil.processParentOverloads(ref, (fType) -> type.set(fType))) { return type.get(); } return nul... | getFunctionalExpressionType |
76,124 | PsiElement () { final PsiMethodReferenceExpression call = getMethodReference(); if (call == null || !canModify(call)) return null; return call; } | getElement |
76,125 | List<PsiClass> (PsiElement element) { List<PsiClass> targets = super.getTargetClasses(element); PsiMethodReferenceExpression call = getMethodReference(); if (call == null) return Collections.emptyList(); return targets; } | getTargetClasses |
76,126 | boolean (PsiClass psiClass) { PsiMethodReferenceExpression reference = getMethodReference(); if (reference != null && reference.isConstructor()) { return false; } return super.canBeTargetClass(psiClass); } | canBeTargetClass |
76,127 | void (@NotNull PsiClass targetClass) { PsiMethodReferenceExpression expression = getMethodReference(); if (expression == null) return; if (isValidElement(expression)) return; PsiClass parentClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class); PsiMember enclosingContext = PsiTreeUtil.getParentOfType(expressi... | invokeImpl |
76,128 | record (ExpectedTypeInfo[] expectedReturn, List<Pair<PsiExpression, PsiType>> arguments) { @NotNull private static ExpectedSignature from(PsiMethodReferenceExpression expression) { final PsiType functionalInterfaceType = getFunctionalExpressionType(expression); final PsiClassType.ClassResolveResult classResolveResult =... | ExpectedSignature |
76,129 | ExpectedSignature (PsiMethodReferenceExpression expression) { final PsiType functionalInterfaceType = getFunctionalExpressionType(expression); final PsiClassType.ClassResolveResult classResolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType); final PsiMethod interfaceMethod = LambdaUtil.getFunctiona... | from |
76,130 | boolean (PsiElement element) { return false; } | isValidElement |
76,131 | String () { return QuickFixBundle.message("create.method.from.usage.family"); } | getFamilyName |
76,132 | PsiMethodReferenceExpression () { return (PsiMethodReferenceExpression)myMethodReferenceExpression.getElement(); } | getMethodReference |
76,133 | String () { return QuickFixBundle.message("make.class.an.interface.family"); } | getFamilyName |
76,134 | void (@NotNull ActionContext context, @NotNull PsiClass myClass, @NotNull ModPsiUpdater updater) { final PsiReferenceList extendsList = myMakeInterface? myClass.getExtendsList() : myClass.getImplementsList(); final PsiReferenceList implementsList = myMakeInterface? myClass.getImplementsList() : myClass.getExtendsList()... | invoke |
76,135 | boolean (int offset) { if (!super.isAvailableImpl(offset)) return false; if(myReferenceExpression.isQualified()) return false; PsiElement scope = myReferenceExpression; do { scope = PsiTreeUtil.getParentOfType(scope, PsiMethod.class, PsiClass.class); if (!(scope instanceof PsiAnonymousClass)) { return scope instanceof ... | isAvailableImpl |
76,136 | String (String varName) { return CommonQuickFixBundle.message("fix.create.title.x", JavaElementKind.PARAMETER.object(), varName); } | getText |
76,137 | PsiElement (@NotNull PsiFile currentFile) { return currentFile; } | getElementToMakeWritable |
76,138 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { PsiMethod method = PsiTreeUtil.getParentOfType(myReferenceExpression, PsiMethod.class); if (method == null) return IntentionPreviewInfo.EMPTY; List<ParameterInfoImpl> infos = getParameterInfos(method); String newParameters ... | generatePreview |
76,139 | void (@NotNull Project project, Editor editor, PsiFile file) { if (CreateFromUsageUtils.isValidReference(myReferenceExpression, false)) return; IdeDocumentHistory.getInstance(project).includeCurrentPlaceAsChangePlace(); PsiMethod method = PsiTreeUtil.getParentOfType(myReferenceExpression, PsiMethod.class); LOG.assertTr... | invoke |
76,140 | void (Editor editor, PsiMethod method, Consumer<PsiMethod> consumer) { final List<PsiMethod> validEnclosingMethods = CommonJavaRefactoringUtil.getEnclosingMethods(method); if (validEnclosingMethods.size() > 1 && !ApplicationManager.getApplication().isUnitTestMode()) { PsiElementListCellRenderer<PsiMethod> renderer = ne... | chooseEnclosingMethod |
76,141 | String (PsiMethod method) { return PsiFormatUtil.formatMethod( method, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_TYPE); } | getElementText |
76,142 | void (@NotNull LightweightWindowEvent event) { highlighter.dropHighlight(); } | onClosed |
76,143 | List<ParameterInfoImpl> (PsiMethod method) { final String parameterName = myReferenceExpression.getReferenceName(); PsiType[] expectedTypes = CreateFromUsageUtils.guessType(myReferenceExpression, false); final List<ParameterInfoImpl> parameterInfos = new ArrayList<>(Arrays.asList(ParameterInfoImpl.fromMethod(method)));... | getParameterInfos |
76,144 | boolean () { return false; } | isAllowOuterTargetClass |
76,145 | String () { return QuickFixBundle.message("create.parameter.from.usage.family"); } | getFamilyName |
76,146 | String () { if (myModules.size() == 1) { PsiClass aClass = myModules.keySet().iterator().next(); return QuickFixBundle .message("move.0.from.module.1.to.2", aClass.getQualifiedName(), myModules.get(aClass).getName(), myCurrentModule.getName()); } return QuickFixBundle.message("move.0.in.1", myReferenceName, myCurrentMo... | getText |
76,147 | String () { return JavaBundle.message("intention.family.move.it"); } | getFamilyName |
76,148 | boolean (@NotNull Project project, Editor editor, PsiFile file) { return !myModules.isEmpty() && ContainerUtil.all(myModules.keySet(), PsiElement::isValid); } | isAvailable |
76,149 | String (PsiClass psiClass) { return psiClass.getQualifiedName(); } | getElementText |
76,150 | String (PsiClass element, String name) { return null; } | getContainerText |
76,151 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { @NlsSafe String name = myReferenceName; if (name == null) { return IntentionPreviewInfo.EMPTY; } Icon icon = ModuleType.get(myCurrentModule).getIcon(); HtmlBuilder builder = new HtmlBuilder() .append(name) .append(" ").appe... | generatePreview |
76,152 | void (Project project, Editor editor, PsiFile file, PsiClass aClass) { RefactoringActionHandler moveHandler = RefactoringActionHandlerFactory.getInstance().createMoveHandler(); DataContext dataContext = EditorUtil.getEditorDataContext(editor); String fqName = aClass.getQualifiedName(); LOG.assertTrue(fqName != null); P... | moveClass |
76,153 | boolean () { return false; } | startInWriteAction |
76,154 | void (@NotNull QuickFixActionRegistrar registrar, @NotNull PsiJavaCodeReferenceElement reference) { PsiElement psiElement = reference.getElement(); @NonNls String referenceName = reference.getRangeInElement().substring(psiElement.getText()); Project project = psiElement.getProject(); PsiFile containingFile = psiElement... | registerFixes |
76,155 | String (final String className, @PsiModifier.ModifierConstant final String modifier) { if (modifier.equals(PsiModifier.PACKAGE_LOCAL)) { return className + "() {}"; } return modifier + " " + className + "() {}"; } | generateConstructor |
76,156 | String () { return QuickFixBundle.message("add.default.constructor.family"); } | getFamilyName |
76,157 | PsiMethod (@NotNull PsiClass psiClass) { return new AddDefaultConstructorFix(psiClass).createMethod(psiClass); } | addDefaultConstructor |
76,158 | String () { return myText; } | getText |
76,159 | String () { return QuickFixBundle.message("rename.wrong.reference.family"); } | getFamilyName |
76,160 | boolean (@NotNull Project project, Editor editor, PsiFile file) { if (!myRefExpr.isValid() || !BaseIntentionAction.canModify(myRefExpr)) return false; PsiElement refName = myRefExpr.getReferenceNameElement(); if (refName == null) return false; PsiExpression qualifier = myRefExpr.getQualifierExpression(); if (qualifier ... | isAvailable |
76,161 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if (element instanceof PsiNamedElement && element instanceof PsiModifierListOwner && myFilterMethods == element instanceof PsiMethod && ((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.STATIC) == myFilterStatics && isAccessible(element)... | execute |
76,162 | boolean (PsiElement element) { if (!(element instanceof PsiCompiledElement) || !(element instanceof PsiMember)) return true; final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(element.getProject()).getResolveHelper(); return resolveHelper.isAccessible((PsiMember)element, myRefExpr, null); } | isAccessible |
76,163 | PsiElement[] () { return PsiUtilCore.toPsiElementArray(myResult.values()); } | getVariants |
76,164 | void (@NotNull Project project, Editor editor, PsiFile file) { PsiExpression qualifier = myRefExpr.getQualifierExpression(); PsiExpression expression = (myRefExpr.getParent() instanceof PsiMethodCallExpression call) ? call : myRefExpr; if (qualifier != null && qualifier.getType() instanceof PsiPrimitiveType && !Express... | invoke |
76,165 | boolean () { return true; } | startInWriteAction |
76,166 | String (String varName) { return QuickFixBundle.message("create.inner.class.from.usage.text", getKind().getDescriptionAccusative(), varName); } | getText |
76,167 | boolean () { return true; } | isAllowOuterTargetClass |
76,168 | boolean (PsiElement element) { PsiJavaCodeReferenceElement ref = element instanceof PsiNewExpression ? ((PsiNewExpression)element).getClassOrAnonymousClassReference() : null; return ref != null && ref.resolve() != null; } | isValidElement |
76,169 | boolean (PsiNewExpression qualifier) { return false; } | rejectContainer |
76,170 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { PsiElement element = PsiTreeUtil.findSameElementInCopy(getElement(), file); List<PsiClass> targetClasses = filterTargetClasses(element, project); if (targetClasses.isEmpty()) return IntentionPreviewInfo.EMPTY; invokeImpl(ta... | generatePreview |
76,171 | void (final PsiClass targetClass) { PsiNewExpression newExpression = getNewExpression(); if (!targetClass.isPhysical()) { newExpression = PsiTreeUtil.findSameElementInCopy(newExpression, targetClass.getContainingFile()); } PsiJavaCodeReferenceElement ref = newExpression.getClassOrAnonymousClassReference(); assert ref !... | invokeImpl |
76,172 | boolean (PsiNewExpression newExpression) { final PsiExpressionStatement expressionStatement = PsiTreeUtil.getParentOfType(newExpression, PsiExpressionStatement.class); if (expressionStatement != null) { final PsiExpression expression = expressionStatement.getExpression(); if (JavaPsiConstructorUtil.isConstructorCall(ex... | isInThisOrSuperCall |
76,173 | boolean (@NotNull ModuleRootManager rootManager, Module classModule, DependencyScope scope) { return ContainerUtil.exists(rootManager.getOrderEntries(), entry -> entry instanceof ModuleOrderEntry && classModule.equals(((ModuleOrderEntry)entry).getModule()) && (scope == DependencyScope.TEST || scope == ((ModuleOrderEntr... | dependsWithScope |
76,174 | boolean (PsiClass aClass, PsiElement refElement) { return JavaResolveUtil.isAccessible(aClass, aClass.getContainingClass(), aClass.getModifierList(), refElement, aClass, null); } | isAccessible |
76,175 | String () { if (myModules.size() == 1) { Module module = ContainerUtil.getFirstItem(myModules); assert module != null; return QuickFixBundle.message("orderEntry.fix.add.dependency.on.module", module.getName()); } return QuickFixBundle.message("orderEntry.fix.add.dependency.on.module.choose"); } | getText |
76,176 | String () { return QuickFixBundle.message("orderEntry.fix.family.add.module.dependency"); } | getFamilyName |
76,177 | boolean (@NotNull Project project, Editor editor, PsiFile file) { return !project.isDisposed() && !myCurrentModule.isDisposed() && !myModules.isEmpty() && !ContainerUtil.exists(myModules, Module::isDisposed); } | isAvailable |
76,178 | void (@NotNull Project project, @Nullable Editor editor, PsiFile file) { if (myModules.size() == 1) { addDependencyOnModule(project, editor, ContainerUtil.getFirstItem(myModules)); } else { JBPopup popup = JBPopupFactory.getInstance() .createPopupChooserBuilder(new ArrayList<>(myModules)) .setRenderer(new ModuleListCel... | invoke |
76,179 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { return new IntentionPreviewInfo.Html( HtmlChunk.text(JavaBundle.message("adds.module.dependencies.preview", myModules.size(), ContainerUtil.getFirstItem(myModules).getName(), NlsMessages.formatAndList(ContainerUtil.map(myMo... | generatePreview |
76,180 | void (@NotNull Project project, Editor editor, @NotNull Module module) { Couple<Module> circularModules = CircularModuleDependenciesDetector.addingDependencyFormsCircularity(myCurrentModule, module); if (circularModules == null || showCircularWarning(project, circularModules, module)) { JavaProjectModelModificationServ... | addDependencyOnModule |
76,181 | boolean (@NotNull Project project, @NotNull Couple<Module> circle, @NotNull Module classModule) { String message = QuickFixBundle.message("orderEntry.fix.circular.dependency.warning", classModule.getName(), circle.getFirst().getName(), circle.getSecond().getName()); String title = QuickFixBundle.message("orderEntry.fix... | showCircularWarning |
76,182 | ModCommand (@NotNull ActionContext context) { PsiClassType aClass = getRuntimeExceptionAtCaret(context); PsiMethod method = PsiTreeUtil.getParentOfType(context.findLeaf(), PsiMethod.class); if (method == null) return ModCommand.nop(); ModCommand command = AddExceptionToThrowsFix.addExceptionsToThrowsList(context.projec... | perform |
76,183 | boolean (PsiMethod method, PsiClassType exception) { PsiClassType[] throwsTypes = method.getThrowsList().getReferencedTypes(); for (PsiClassType throwsType : throwsTypes) { if (throwsType.isAssignableFrom(exception)) { return true; } } return false; } | isMethodThrows |
76,184 | PsiClassType (@NotNull ActionContext context) { PsiElement element = context.findLeaf(); if (element == null) return null; PsiThrowStatement expression = PsiTreeUtil.getParentOfType(element, PsiThrowStatement.class); if (expression == null) return null; PsiExpression exception = expression.getException(); if (exception... | getRuntimeExceptionAtCaret |
76,185 | String () { return QuickFixBundle.message("add.runtime.exception.to.throws.family"); } | getFamilyName |
76,186 | String () { return QuickFixBundle.message("reuse.variable.declaration.family"); } | getFamilyName |
76,187 | void (@NotNull ActionContext context, @NotNull PsiLocalVariable variable, @NotNull ModPsiUpdater updater) { final PsiVariable refVariable = findPreviousVariable(variable); if (refVariable == null) return; final PsiExpression initializer = variable.getInitializer(); if (initializer == null) { variable.delete(); return; ... | invoke |
76,188 | PsiVariable (PsiLocalVariable variable) { PsiElement scope = variable.getParent(); while (scope != null) { if (scope instanceof PsiFile || scope instanceof PsiMethod || scope instanceof PsiClassInitializer) break; scope = scope.getParent(); } if (scope == null) return null; PsiIdentifier nameIdentifier = variable.getNa... | findPreviousVariable |
76,189 | boolean (@NotNull PsiMethod ctor) { PsiClass containingClass = ctor.getContainingClass(); if (containingClass == null) return false; return ContainerUtil.exists(containingClass.getConstructors(), constructor -> constructor != ctor); } | hasConstructorToDelegate |
76,190 | ModCommand (@NotNull ActionContext context, @NotNull PsiElement element) { final Set<PsiClassType> exceptions = new HashSet<>(); final PsiMethod targetMethod = collectExceptions(exceptions, element); if (targetMethod == null) return ModCommand.nop(); ModCommand command = addExceptionsToThrowsList(context.project(), tar... | perform |
76,191 | void (@NotNull PsiMethod method, @NotNull List<? super PsiMethod> result) { PsiMethod[] superMethods = method.findSuperMethods(); for (PsiMethod superMethod : superMethods) { result.add(superMethod); collectSuperMethods(superMethod, result); } } | collectSuperMethods |
76,192 | boolean (PsiMethod @NotNull [] superMethods, @NotNull Set<? extends PsiClassType> unhandledExceptions) { for (PsiMethod superMethod : superMethods) { PsiClassType[] referencedTypes = superMethod.getThrowsList().getReferencedTypes(); Set<PsiClassType> exceptions = new HashSet<>(unhandledExceptions); for (PsiClassType re... | hasSuperMethodsWithoutExceptions |
76,193 | PsiMethod (Set<? super PsiClassType> unhandled, PsiElement element) { PsiElement targetElement = null; PsiMethod targetMethod = null; final PsiElement psiElement; if (element instanceof PsiMethodReferenceExpression) { psiElement = element; } else { PsiElement parentStatement = CommonJavaRefactoringUtil.getParentStateme... | collectExceptions |
76,194 | String () { return QuickFixBundle.message("add.exception.to.throws.family"); } | getFamilyName |
76,195 | List<PsiClassType> (@Nullable PsiElement element, PsiElement topElement, PsiMethod targetMethod) { if (element == null || element == topElement && !(topElement instanceof PsiMethodReferenceExpression)) return null; List<PsiClassType> unhandledExceptions = ExceptionUtil.getUnhandledExceptions(element); if (!filterInProj... | getUnhandledExceptions |
76,196 | Set<PsiClassType> (@Nullable PsiMethod targetMethod, @NotNull List<? extends PsiClassType> unhandledExceptions) { if (targetMethod == null) return Collections.emptySet(); Set<PsiClassType> result = new HashSet<>(); if (BaseIntentionAction.canModify(targetMethod)) { PsiMethod[] superMethods = targetMethod.findSuperMetho... | filterInProjectExceptions |
76,197 | String () { return QuickFixBundle.message("convert.to.string.family"); } | getFamilyName |
76,198 | void (@NotNull ActionContext context, @NotNull PsiJavaToken element, @NotNull ModPsiUpdater updater) { final String text = StringUtil.unescapeStringCharacters(element.getText()); final int length = text.length(); if (length > 1 && text.charAt(0) == '\'' && text.charAt(length - 1) == '\'') { final String value = StringU... | invoke |
76,199 | String (@NotNull PsiExpression subExpression) { String suffix = ""; if (SideEffectChecker.mayHaveSideEffects(subExpression, e -> shouldIgnore(e, subExpression))) { suffix = canExtractSideEffect(subExpression) ? QuickFixBundle.message("simplify.boolean.expression.extracting.side.effects") : JavaBundle.message("quickfix.... | getText |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.