Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
75,200 | IntentionAction (@NotNull PsiExpression expression, boolean value) { return new SimplifyBooleanExpressionFix(expression, value).asIntention(); } | createSimplifyBooleanFix |
75,201 | IntentionAction (@NotNull PsiVariable variable, @NotNull PsiType type) { return new SetVariableTypeFix(variable, type).asIntention(); } | createSetVariableTypeFix |
75,202 | IntentionAction (@NotNull PsiReceiverParameter parameter, @NotNull String newName) { return new ReceiverParameterNameFix(parameter, newName).asIntention(); } | createReceiverParameterNameFix |
75,203 | IntentionAction (@NotNull PsiLambdaExpression lambdaExpression, @IntentionName String message) { return new RemoveRedundantLambdaParameterTypesFix(lambdaExpression, message).asIntention(); } | createRemoveRedundantLambdaParameterTypesFix |
75,204 | IntentionAction (@NotNull PsiAnonymousClass anonymousClass) { return new MoveAnonymousOrLocalToInnerFix(anonymousClass); } | createConvertAnonymousToInnerAction |
75,205 | IntentionAction (@NotNull PsiClass localClass) { return new MoveAnonymousOrLocalToInnerFix(localClass); } | createConvertLocalToInnerAction |
75,206 | Presentation (@NotNull ActionContext context, @NotNull PsiLambdaExpression element) { return Presentation.of(myMessage); } | getPresentation |
75,207 | IntentionAction () { return new SplitSwitchBranchWithSeveralCaseValuesAction().asIntention(); } | createSplitSwitchBranchWithSeveralCaseValuesAction |
75,208 | IntentionAction (@NotNull PsiElement @NotNull [] elements, @NotNull @Nls String text) { return new DeleteElementFix.DeleteMultiFix(elements, text).asIntention(); } | createDeleteFix |
75,209 | ModCommandAction (@NotNull PsiCaseLabelElementList list) { return new ReplaceCaseDefaultWithDefaultFix(list); } | createReplaceCaseDefaultWithDefaultFix |
75,210 | ModCommandAction (@NotNull PsiCaseLabelElementList list) { return new ReverseCaseDefaultNullFix(list); } | createReverseCaseDefaultNullFixFix |
75,211 | IntentionAction (@NotNull PsiUnnamedClass unnamedClass) { return new AddMainMethodFix(unnamedClass).asIntention(); } | createAddMainMethodFix |
75,212 | String (@NotNull String refSuffix, @NotNull Editor editor) { return StringUtil.unescapeXmlEntities(refSuffix); } | getDescription |
75,213 | String (@NotNull String refSuffix, @NotNull Editor editor) { return JavaBundle.message("inspection.message.full.description"); } | getDescriptionTitle |
75,214 | boolean (PsiStatement statement) { if (!(statement instanceof PsiIfStatement)) return false; PsiExpression condition = ((PsiIfStatement)statement).getCondition(); if (condition == null) return false; if (BoolUtils.isNegation(condition)) { condition = BoolUtils.getNegated(condition); } if (condition instanceof PsiBinary... | isFinishCondition |
75,215 | void (@NotNull ActionContext context, @NotNull PsiParameterListOwner element, @NotNull ModPsiUpdater updater) { if (!(element.getBody() instanceof PsiCodeBlock block)) return; Project project = context.project(); generateBody(project, block, new EmptyProgressIndicator()); } | invoke |
75,216 | void (@NotNull Project project, PsiCodeBlock block, ProgressIndicator indicator) { indicator.setIndeterminate(false); PsiType returnType = PsiTypesUtil.getMethodReturnType(block); if (returnType == null) return; List<PsiReturnStatement> returns = Arrays.asList(PsiUtil.findReturnStatements(block)); indicator.checkCancel... | generateBody |
75,217 | PsiLocalVariable (@NotNull Project project, PsiCodeBlock block, PsiType returnType, FinishMarker marker, int count, ProgressIndicator indicator) { ExitContext exitContext = new ExitContext(block, returnType, marker); int i=0; while (true) { indicator.checkCanceled(); indicator.setFraction(0.3 + 0.6 * (i++) / count); Pr... | convertReturns |
75,218 | PsiReturnStatement (@NotNull PsiCodeBlock block) { PsiStatement lastStatement = ArrayUtil.getLastElement(block.getStatements()); if (lastStatement == null) return null; class Visitor extends JavaRecursiveElementWalkingVisitor { private PsiReturnStatement myReturnStatement; @Override public void visitReturnStatement(@No... | getNonTerminalReturn |
75,219 | void (@NotNull PsiReturnStatement statement) { super.visitReturnStatement(statement); if (lastStatement != statement) { myReturnStatement = statement; stopWalking(); } } | visitReturnStatement |
75,220 | void (@NotNull PsiErrorElement element) { stopWalking(); } | visitErrorElement |
75,221 | void (@NotNull PsiExpression expression) {} | visitExpression |
75,222 | void (@NotNull PsiLambdaExpression expression) {} | visitLambdaExpression |
75,223 | void (@NotNull PsiClass aClass) {} | visitClass |
75,224 | String () { return JavaBundle.message("intention.convert.to.single.return.name"); } | getFamilyName |
75,225 | FinishMarker (@NotNull PsiCodeBlock block, @NotNull PsiType returnType, List<? extends PsiReturnStatement> returns) { boolean mayNeedMarker = mayNeedMarker(returns, block); return defineFinishMarker(block, returns, returnType, mayNeedMarker, JavaPsiFacade.getElementFactory(block.getProject())); } | defineFinishMarker |
75,226 | boolean (List<? extends PsiReturnStatement> returns, PsiCodeBlock block) { for (PsiReturnStatement returnStatement : returns) { if (mayNeedMarker(returnStatement, block)) return true; } return false; } | mayNeedMarker |
75,227 | boolean (PsiReturnStatement returnStatement, PsiCodeBlock block) { PsiElement parent = returnStatement.getParent(); while (parent instanceof PsiCodeBlock) { PsiElement grandParent = parent.getParent(); if (grandParent instanceof PsiBlockStatement) { parent = grandParent.getParent(); continue; } if (grandParent instance... | mayNeedMarker |
75,228 | FinishMarker (PsiCodeBlock block, List<? extends PsiReturnStatement> returns, PsiType returnType, boolean mayNeedMarker, PsiElementFactory factory) { if (PsiTypes.voidType().equals(returnType)) { return new FinishMarker(FinishMarkerType.SEPARATE_VAR, null); } PsiReturnStatement terminalReturn = tryCast(ArrayUtil.getLas... | defineFinishMarker |
75,229 | PsiExpression (PsiReturnStatement terminalReturn, List<PsiExpression> nonTerminalReturns, boolean mayNeedMarker) { List<PsiExpression> bestGroup = StreamEx.of(nonTerminalReturns) .filter(FinishMarker::canMoveToStart) .groupingBy(PsiExpression::getText, LinkedHashMap::new, Collectors.toList()) .values() .stream() .max(C... | findBestExpression |
75,230 | FinishMarker (List<PsiExpression> nonTerminalReturns, PsiReturnStatement terminalReturn, PsiType returnType, PsiElementFactory factory) { boolean isLong = PsiTypes.longType().equals(returnType); LongRangeSet fullSet = requireNonNull(JvmPsiRangeSetUtil.typeRange(returnType)); LongRangeSet set = nonTerminalReturns.stream... | getMarkerForIntegral |
75,231 | boolean (PsiExpression value) { if (!ExpressionUtils.isSafelyRecomputableExpression(value)) return false; PsiReferenceExpression ref = tryCast(PsiUtil.skipParenthesizedExprDown(value), PsiReferenceExpression.class); if (ref != null && !ref.isQualified()) { PsiVariable target = tryCast(ref.resolve(), PsiVariable.class);... | canMoveToStart |
75,232 | void () { PsiExpression value = myReturnStatement.getReturnValue(); PsiStatement currentContext = goUp(); if (currentContext == null) return; if (value != null) { myExitContext.registerReturnValue(value, myReplacements); } while (currentContext != null) { currentContext = advance(currentContext); } replace(); } | process |
75,233 | PsiStatement () { PsiElement parent = myReturnStatement.getParent(); while (parent instanceof PsiCodeBlock) { PsiElement grandParent = parent.getParent(); if (!(grandParent instanceof PsiSwitchStatement)) { PsiStatement[] statements = ((PsiCodeBlock)parent).getStatements(); boolean afterReturn = false; for (PsiStatemen... | goUp |
75,234 | PsiStatement (PsiStatement currentContext) { PsiElement contextParent = currentContext.getParent(); if (contextParent instanceof PsiLoopStatement) { Object mark = new Object(); PsiTreeUtil.mark(myReturnStatement, mark); currentContext = BlockUtils.expandSingleStatementToBlockStatement(currentContext); contextParent = c... | advance |
75,235 | void (PsiElement element) { Set<PsiLocalVariable> locals = new HashSet<>(); PsiTreeUtil.processElements(element, e -> { if (e instanceof PsiReferenceExpression) { PsiLocalVariable variable = ExpressionUtils.resolveLocalVariable((PsiExpression)e); if (variable != null && variable.getInitializer() == null && PsiTreeUtil.... | fixNonInitializedVars |
75,236 | PsiCodeBlock (PsiStatement currentContext, PsiIfStatement ifStatement, boolean inThen, PsiCodeBlock ifParent) { PsiElement[] tail = extractTail(currentContext, ifParent); if (!ContainerUtil.exists(tail, PsiStatement.class::isInstance)) return null; PsiBlockStatement blockForTail = getBlockFromIf(ifStatement, inThen); P... | swallowTail |
75,237 | PsiBlockStatement (PsiIfStatement ifStatement, boolean inThen) { if (inThen) { PsiStatement elseBranch = ifStatement.getElseBranch(); if (elseBranch == null) { ifStatement.setElseBranch(BlockUtils.createBlockStatement(myProject)); return (PsiBlockStatement)ifStatement.getElseBranch(); } if (!(elseBranch instanceof PsiB... | getBlockFromIf |
75,238 | void () { if (!(myReturnStatement.getParent() instanceof PsiCodeBlock)) { myReturnStatement = BlockUtils.expandSingleStatementToBlockStatement(myReturnStatement); } PsiStatement[] newStatements = ContainerUtil.map2Array( myReplacements, PsiStatement.class, text -> myFactory.createStatementFromText(text, null)); if (new... | replace |
75,239 | void (PsiElement place) { while (place != null && place != myBlock) { if (place instanceof PsiBlockStatement) { PsiIfStatement parentIf = tryCast(place.getParent(), PsiIfStatement.class); if (parentIf != null && parentIf.getElseBranch() == place) { PsiIfStatement childIf = tryCast(ControlFlowUtils.stripBraces((PsiState... | stripUnnecessaryBlocks |
75,240 | PsiElement (PsiCodeBlock block) { if (block == null || !block.isEmpty()) return block; PsiBlockStatement blockStatement = tryCast(block.getParent(), PsiBlockStatement.class); if (blockStatement == null) return block; PsiIfStatement parent = tryCast(blockStatement.getParent(), PsiIfStatement.class); if (parent == null) ... | cleanUpEmptyBlocks |
75,241 | void (@NotNull Project project, PsiCodeBlock block, ExitContext exitContext, PsiReturnStatement returnStatement) { new ReturnReplacementContext(project, block, exitContext, returnStatement).process(); } | replaceSingleReturn |
75,242 | HighlightUsagesHandlerBase (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (target instanceof PsiKeyword) { if (PsiKeyword.RETURN.equals(target.getText()) || PsiKeyword.THROW.equals(target.getText())) { return new HighlightExitPointsHandler(editor, file, target); } if (PsiKeyword.CONTIN... | createHighlightUsagesHandler |
75,243 | List<PsiElement> () { return Collections.singletonList(myTarget); } | getTargets |
75,244 | void (@NotNull List<? extends PsiElement> targets, @NotNull Consumer<? super List<? extends PsiElement>> selectionConsumer) { selectionConsumer.consume(targets); } | selectTargets |
75,245 | void (@NotNull List<? extends PsiElement> targets) { PsiElement parent = myTarget.getParent(); if (parent instanceof PsiContinueStatement) { PsiElement statement = ((PsiContinueStatement)parent).findContinuedStatement(); if (statement instanceof PsiLoopStatement) { processLoop((PsiStatement)parent, (PsiLoopStatement)st... | computeUsages |
75,246 | void (PsiStatement parent, PsiLoopStatement statement) { highlightLoopDeclaration(statement); PsiStatement body = statement.getBody(); if (body instanceof PsiBlockStatement) { collectSiblings(parent, statement, ((PsiBlockStatement)body).getCodeBlock()); } } | processLoop |
75,247 | void (PsiStatement currentStatement, PsiElement container, @NotNull PsiElement block) { try { ControlFlow controlFlow = ControlFlowFactory.getControlFlow(block, new LocalsControlFlowPolicy(block), ControlFlowOptions.NO_CONST_EVALUATE); Collection<PsiStatement> statements = ControlFlowUtil .findExitPointsAndStatements(c... | collectSiblings |
75,248 | void (PsiLoopStatement statement) { if (statement instanceof PsiDoWhileStatement) { PsiKeyword whileKeyword = ((PsiDoWhileStatement)statement).getWhileKeyword(); if (whileKeyword != null) { addOccurrence(whileKeyword); } } else { addOccurrence(statement.getFirstChild()); } } | highlightLoopDeclaration |
75,249 | List<PsiElement> () { return Collections.singletonList(myTarget); } | getTargets |
75,250 | void (final @NotNull List<? extends PsiElement> targets, final @NotNull Consumer<? super List<? extends PsiElement>> selectionConsumer) { selectionConsumer.consume(targets); } | selectTargets |
75,251 | void (final @NotNull List<? extends PsiElement> targets) { PsiElement parent = myTarget.getParent(); if (!(parent instanceof PsiReturnStatement) && !(parent instanceof PsiThrowStatement)) return; PsiCodeBlock body = null; final PsiElement psiElement = PsiTreeUtil.getParentOfType(myTarget, PsiLambdaExpression.class, Psi... | computeUsages |
75,252 | PsiElement (PsiStatement exitStatement) { if (exitStatement instanceof PsiReturnStatement) { return PsiTreeUtil.getParentOfType(exitStatement, PsiMethod.class); } else if (exitStatement instanceof PsiBreakStatement) { return ((PsiBreakStatement)exitStatement).findExitedStatement(); } else if (exitStatement instanceof P... | getExitTarget |
75,253 | String () { return ProductivityFeatureNames.CODEASSISTS_HIGHLIGHT_RETURN; } | getFeatureId |
75,254 | HighlightUsagesHandlerBase<PsiMember> (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (!(target instanceof PsiKeyword) || !PsiKeyword.IMPORT.equals(target.getText())) { return null; } final PsiElement parent = target.getParent(); if (!(parent instanceof PsiImportStatementBase)) { return... | createHighlightUsagesHandler |
75,255 | HighlightUsagesHandlerBase (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (target instanceof PsiKeyword) { PsiElement parent = target.getParent(); if (PsiKeyword.TRY.equals(target.getText()) && parent instanceof PsiTryStatement) { return createHighlightTryHandler(editor, file, target, ... | createHighlightUsagesHandler |
75,256 | HighlightUsagesHandlerBase<PsiClass> (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target, @NotNull PsiElement parent) { FeatureUsageTracker.getInstance().triggerFeatureUsed("codeassists.highlight.throws"); PsiCodeBlock tryBlock = ((PsiTryStatement)parent).getTryBlock(); if (tryBlock == null) retu... | createHighlightTryHandler |
75,257 | HighlightUsagesHandlerBase<PsiClass> (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target, @NotNull PsiJavaCodeReferenceElement parent) { PsiElement list = parent.getParent(); if (!(list instanceof PsiReferenceList)) return null; PsiElement method = list.getParent(); if (!(method instanceof PsiMet... | createHighlightExceptionUsagesFromThrowsHandler |
75,258 | HighlightUsagesHandlerBase<PsiClass> (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target, @NotNull PsiElement parent) { FeatureUsageTracker.getInstance().triggerFeatureUsed("codeassists.highlight.throws"); PsiTryStatement tryStatement = ((PsiCatchSection)parent).getTryStatement(); PsiParameter pa... | createHighlightCatchHandler |
75,259 | HighlightUsagesHandlerBase<PsiClass> (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { FeatureUsageTracker.getInstance().triggerFeatureUsed("codeassists.highlight.throws"); PsiElement grand = target.getParent().getParent(); if (!(grand instanceof PsiMethod)) return null; PsiCodeBlock body = ... | createThrowsHandler |
75,260 | List<PsiClass> () { return ChooseClassAndDoHighlightRunnable.resolveClasses(myClassTypes); } | getTargets |
75,261 | void (final @NotNull List<? extends PsiClass> targets, final @NotNull Consumer<? super List<? extends PsiClass>> selectionConsumer) { new ChooseClassAndDoHighlightRunnable(myClassTypes, myEditor, JavaBundle.message("highlight.exceptions.thrown.chooser.title")) { @Override protected void selected(PsiClass @NotNull ... c... | selectTargets |
75,262 | void (PsiClass @NotNull ... classes) { selectionConsumer.consume(Arrays.asList(classes)); } | selected |
75,263 | void (final @NotNull List<? extends PsiClass> targets) { addUsage(myTarget); PsiElementFactory factory = JavaPsiFacade.getElementFactory(myFile.getProject()); for (PsiClass aClass : targets) { addExceptionThrowPlaces(factory.createType(aClass), myPlace); if (myOtherPlace != null) { addExceptionThrowPlaces(factory.creat... | computeUsages |
75,264 | void (@NotNull PsiClassType type, @NotNull PsiElement place) { place.accept(new JavaRecursiveElementWalkingVisitor() { @Override public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) { visitElement(expression); } @Override public void visitThrowStatement(@NotNull PsiThrowStatement statement) ... | addExceptionThrowPlaces |
75,265 | void (@NotNull PsiReferenceExpression expression) { visitElement(expression); } | visitReferenceExpression |
75,266 | void (@NotNull PsiThrowStatement statement) { super.visitThrowStatement(statement); List<PsiClassType> actualTypes = ExceptionUtil.getUnhandledExceptions(statement, place); for (PsiClassType actualType : actualTypes) { if (actualType != null && type.isAssignableFrom(actualType) && myTypeFilter.test(actualType)) { PsiEx... | visitThrowStatement |
75,267 | void (@NotNull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); PsiReference reference = expression.getMethodExpression().getReference(); if (reference != null) { List<PsiClassType> exceptionTypes = ExceptionUtil.getUnhandledExceptions(expression, place); for (final PsiClassType actual... | visitMethodCallExpression |
75,268 | void (@NotNull PsiNewExpression expression) { super.visitNewExpression(expression); PsiJavaCodeReferenceElement classReference = expression.getClassOrAnonymousClassReference(); if (classReference != null) { List<PsiClassType> exceptionTypes = ExceptionUtil.getUnhandledExceptions(expression, place); for (PsiClassType ac... | visitNewExpression |
75,269 | void (@NotNull PsiResourceExpression expression) { super.visitResourceExpression(expression); List<PsiClassType> exceptionTypes = ExceptionUtil.getUnhandledCloserExceptions(expression, place); for (PsiClassType actualType : exceptionTypes) { if (type.isAssignableFrom(actualType) && myTypeFilter.test(actualType)) { addU... | visitResourceExpression |
75,270 | void (@NotNull PsiResourceVariable variable) { super.visitResourceVariable(variable); List<PsiClassType> exceptionTypes = ExceptionUtil.getUnhandledCloserExceptions(variable, place); for (PsiClassType actualType : exceptionTypes) { if (type.isAssignableFrom(actualType) && myTypeFilter.test(actualType)) { PsiIdentifier ... | visitResourceVariable |
75,271 | void (@NotNull PsiElement element) { addOccurrence(element); } | addUsage |
75,272 | List<PsiMember> () { final PsiJavaCodeReferenceElement importReference = myImportStatement.getImportReference(); if (importReference == null) { return Collections.emptyList(); } final PsiJavaFile javaFile = PsiTreeUtil.getParentOfType(importReference, PsiJavaFile.class); if (javaFile == null) { return Collections.empty... | getTargets |
75,273 | void (final @NotNull List<? extends PsiMember> targets, final @NotNull Consumer<? super List<? extends PsiMember>> selectionConsumer) { if (targets.isEmpty()) { selectionConsumer.consume(Collections.emptyList()); return; } if (targets.size() == 1) { selectionConsumer.consume(Collections.singletonList(targets.get(0))); ... | selectTargets |
75,274 | void (@NotNull List<? extends PsiMember> targets) { if (targets.isEmpty()) { buildStatusText("import", 0); return; } if (myClassReferenceListMap == null) { return; } addOccurrence(myTarget); for (PsiMember target : targets) { final List<PsiElement> elements = myClassReferenceListMap.get(target); for (PsiElement element... | computeUsages |
75,275 | void (@NotNull PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); if (!myImportStatic && reference.getText().equals(reference.getQualifiedName())) { return; } PsiElement parent = reference.getParent(); if (parent instanceof PsiImportStatementBase) { return; } while (parent instanceof PsiJa... | visitReferenceElement |
75,276 | void (PsiJavaCodeReferenceElement reference) { if (reference.isQualified()) { return; } final PsiElement target = reference.resolve(); if (!(target instanceof PsiMethod) && !(target instanceof PsiClass) && !(target instanceof PsiField)) { return; } final PsiMember member = (PsiMember)target; for (PsiElement importTarge... | checkStaticImportReference |
75,277 | void (PsiJavaCodeReferenceElement reference) { final PsiElement element = reference.resolve(); if (!(element instanceof PsiClass referencedClass)) { return; } for (PsiElement importTarget : myImportTargets) { if (importTarget instanceof PsiPackage aPackage) { if (referencedClass.getContainingClass() != null) { return; ... | checkImportReference |
75,278 | void (PsiMember referencedMember, PsiJavaCodeReferenceElement reference) { List<PsiElement> referenceList = classReferenceListMap.get(referencedMember); if (referenceList == null) { referenceList = new ArrayList<>(); classReferenceListMap.put(referencedMember, referenceList); } referenceList.add(reference.getReferenceN... | addReference |
75,279 | int (PsiMember member1, PsiMember member2) { final String name1 = member1.getName(); if (name1 == null) { return -1; } final String name2 = member2.getName(); if (name2 == null) { return 1; } final int i = name1.compareTo(name2); if (i != 0) { return i; } final PsiJavaFile file1 = (PsiJavaFile)member1.getContainingFile... | compare |
75,280 | HighlightUsagesHandlerBase<PsiRecordComponent> (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (!(target instanceof PsiIdentifier)) return null; PsiElement parent = target.getParent(); if (!(parent instanceof PsiReferenceExpression)) return null; PsiElement resolved = ((PsiReferenceExpr... | createHighlightUsagesHandler |
75,281 | List<PsiRecordComponent> () { return Collections.singletonList(myComponent); } | getTargets |
75,282 | void (@NotNull List<? extends PsiRecordComponent> targets, @NotNull Consumer<? super List<? extends PsiRecordComponent>> selectionConsumer) { selectionConsumer.consume(targets); } | selectTargets |
75,283 | void (@NotNull List<? extends PsiRecordComponent> targets) { assert targets.size() == 1; PsiRecordComponent record = targets.get(0); PsiIdentifier nameIdentifier = record.getNameIdentifier(); if (nameIdentifier != null) { addOccurrence(nameIdentifier); final String name = nameIdentifier.getText(); Consumer<PsiExpressio... | computeUsages |
75,284 | void (@NotNull PsiReferenceExpression expression) { super.visitReferenceExpression(expression); if (isReferenceToRecordComponent(name, expression)) { onOccurence.consume(expression); } } | visitReferenceExpression |
75,285 | boolean (String name, PsiReferenceExpression referenceExpression) { if (!name.equals(referenceExpression.getReferenceName())) return false; LightRecordMember recordMember = tryCast(referenceExpression.resolve(), LightRecordMember.class); if (recordMember == null) return false; return recordMember.getRecordComponent() =... | isReferenceToRecordComponent |
75,286 | HighlightUsagesHandlerBase (@NotNull Editor editor, @NotNull PsiFile file, @NotNull PsiElement target) { if (target instanceof PsiKeyword && (PsiKeyword.EXTENDS.equals(target.getText()) || PsiKeyword.IMPLEMENTS.equals(target.getText()))) { PsiElement parent = target.getParent(); if (!(parent instanceof PsiReferenceList... | createHighlightUsagesHandler |
75,287 | List<PsiClass> (PsiClassType @NotNull [] classTypes) { List<PsiClass> classes = new ArrayList<>(); for (PsiClassType classType : classTypes) { PsiClass aClass = classType.resolve(); if (aClass != null) classes.add(aClass); } return classes; } | resolveClasses |
75,288 | PsiElementListCellRenderer<PsiClass> () { return new PsiClassListCellRenderer(); } | createRenderer |
75,289 | List<PsiClass> () { PsiReferenceList list = PsiKeyword.EXTENDS.equals(myTarget.getText()) ? myClass.getExtendsList() : myClass.getImplementsList(); if (list == null) return Collections.emptyList(); final PsiClassType[] classTypes = list.getReferencedTypes(); return ChooseClassAndDoHighlightRunnable.resolveClasses(class... | getTargets |
75,290 | void (final @NotNull List<? extends PsiClass> targets, final @NotNull Consumer<? super List<? extends PsiClass>> selectionConsumer) { new ChooseClassAndDoHighlightRunnable(targets, myEditor, JavaBundle.message("highlight.overridden.classes.chooser.title")) { @Override protected void selected(PsiClass @NotNull ... class... | selectTargets |
75,291 | void (PsiClass @NotNull ... classes) { selectionConsumer.consume(Arrays.asList(classes)); } | selected |
75,292 | void (final @NotNull List<? extends PsiClass> classes) { for (PsiMethod method : myClass.getMethods()) { List<HierarchicalMethodSignature> superSignatures = method.getHierarchicalMethodSignature().getSuperSignatures(); for (HierarchicalMethodSignature superSignature : superSignatures) { PsiClass containingClass = super... | computeUsages |
75,293 | String () { return "codeassists.highlight.implements"; } | getFeatureId |
75,294 | void () { // ask user whether she wants to highlight target exception usages or places that throws that exception String className = "'" + ((PsiClass)myResolved).getName() + "'"; String throwingPlacesMode = JavaBundle.message("highlight.throws.popup.throwing.places", className); String showUsagesMode = JavaBundle.messa... | highlightUsages |
75,295 | void (@NotNull JList<? extends String> list, @NlsContexts.Label String value, int index, boolean selected, boolean hasFocus) { setIcon(showUsagesMode.equals(value) ? AllIcons.Nodes.Class : AllIcons.Nodes.ExceptionClass); setText(value); } | customize |
75,296 | JComponent (ButtonKind data, @NotNull Project project) { if (project.isDefault()) { // Do not provide button for default project return new JPanel(); } return switch (data) { case NULLABILITY_ANNOTATIONS -> NullableNotNullDialog.createConfigureAnnotationsButton(project); case ENTRY_POINT_CODE_PATTERNS -> EntryPointsMan... | render |
75,297 | String (ButtonKind kind) { return kind.name(); } | serializeData |
75,298 | ButtonKind (@NotNull String data) { return ButtonKind.valueOf(data); } | deserializeData |
75,299 | OptCustom (@NotNull JavaInspectionButtons.ButtonKind kind) { return new JavaInspectionButtons().component(kind); } | button |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.