Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
75,500 | TypeParameterInfo () { return myInfo; } | getInfo |
75,501 | PsiTypeCodeFragment () { return myBoundValueFragment; } | getBoundValueFragment |
75,502 | PsiTypeCodeFragment () { return myDefaultValueFragment; } | getDefaultValueFragment |
75,503 | Template (PsiField field, Object expectedTypes, PsiClass targetClass, Editor editor, PsiElement context, boolean createConstantField) { CreateFieldFromUsageHelper helper = EP_NAME.forLanguage(field.getLanguage()); if (helper == null) return null; return helper.setupTemplateImpl(field, expectedTypes, targetClass, editor... | setupTemplate |
75,504 | PsiField (@NotNull PsiClass targetClass, @NotNull PsiField field, @NotNull PsiElement place) { CreateFieldFromUsageHelper helper = EP_NAME.forLanguage(field.getLanguage()); if (helper == null) return null; return helper.insertFieldImpl(targetClass, field, place); } | insertField |
75,505 | String () { return JavaBundle.message("qualify.static.call.fix.text"); } | getBaseText |
75,506 | QuestionAction (@NotNull List<? extends PsiMethod> methodsToImport, @NotNull Project project, Editor editor) { return new StaticImportMemberQuestionAction<PsiMethod>(project, editor, methodsToImport, myReferencePointer) { @Override protected void doImport(@NotNull PsiMethod toImport) { PsiMethodCallExpression element =... | createQuestionAction |
75,507 | void (@NotNull PsiMethod toImport) { PsiMethodCallExpression element = myReferencePointer.getElement(); if (element == null) return; WriteCommandAction.runWriteCommandAction(project, JavaBundle.message("qualify.static.access.command.name"), null, () -> qualifyStatically(toImport, project, element.getMethodExpression())... | doImport |
75,508 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { return generatePreview(file, (expression, method) -> qualifyStatically(method, project, ((PsiMethodCallExpression)expression).getMethodExpression())); } | generatePreview |
75,509 | void (@NotNull PsiMember toImport, @NotNull Project project, @NotNull PsiReferenceExpression qualifiedExpression) { PsiClass containingClass = toImport.getContainingClass(); if (containingClass == null) return; PsiReferenceExpression qualifier = JavaPsiFacade.getElementFactory(project).createReferenceExpression(contain... | qualifyStatically |
75,510 | String () { return QuickFixBundle.message("make.vararg.parameter.last.family"); } | getFamilyName |
75,511 | void (@NotNull ActionContext context, @NotNull PsiVariable parameter, @NotNull ModPsiUpdater updater) { parameter.getParent().add(parameter); parameter.delete(); } | invoke |
75,512 | String () { return QuickFixBundle.message("replace.with.list.access.text"); } | getFamilyName |
75,513 | PsiType (@NotNull Project project, @NotNull PsiArrayAccessExpression arrayAccess) { final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); final PsiClass listClass = JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_UTIL_LIST, arrayAccess.getResolveScope()); if (listClass == null) return null... | createUtilListType |
75,514 | void (@NotNull ActionContext context, @NotNull PsiArrayAccessExpression arrayAccess, @NotNull ModPsiUpdater updater) { final PsiExpression arrayExpression = arrayAccess.getArrayExpression(); final PsiExpression indexExpression = arrayAccess.getIndexExpression(); if (indexExpression == null) return; Project project = co... | invoke |
75,515 | void (@NotNull PsiElementFactory factory, @NotNull CodeStyleManager codeStyleManager, @NotNull PsiExpression arrayExpression, @NotNull PsiExpression indexExpression, @NotNull PsiElement anchor) { final PsiElement listAccess = factory.createExpressionFromText( arrayExpression.getText() + ".get(" + indexExpression.getTex... | replaceWithGet |
75,516 | void (@NotNull PsiElementFactory factory, @NotNull CodeStyleManager codeStyleManager, @NotNull PsiExpression arrayExpression, @NotNull PsiExpression indexExpression, @NotNull PsiExpression expression, @NotNull PsiElement anchor) { final PsiElement listAccess = factory.createExpressionFromText( arrayExpression.getText()... | replaceWithSet |
75,517 | void (@NotNull ActionContext context, @NotNull PsiReferenceExpression place, @NotNull ModPsiUpdater updater) { String qualifier = null; final PsiExpression qualifierExpression = place.getQualifierExpression(); if (qualifierExpression != null) { qualifier = qualifierExpression.getText(); } Project project = context.proj... | invoke |
75,518 | String () { return QuickFixBundle.message("replace.with.getter.setter"); } | getFamilyName |
75,519 | String () { return CommonQuickFixBundle.message("fix.replace.x.with.y", PsiKeyword.SWITCH, PsiKeyword.IF); } | getFamilyName |
75,520 | boolean (@NotNull PsiSwitchStatement switchStatement) { final PsiCodeBlock body = switchStatement.getBody(); return body != null && !body.isEmpty() && BreakConverter.from(switchStatement) != null && !mayFallThroughNonTerminalDefaultCase(body); } | isAvailable |
75,521 | boolean (PsiCodeBlock body) { List<PsiSwitchLabelStatementBase> labels = PsiTreeUtil.getChildrenOfTypeAsList(body, PsiSwitchLabelStatementBase.class); return StreamEx.of(labels).pairMap((prev, next) -> { if (SwitchUtils.isDefaultLabel(prev)) { Set<PsiSwitchLabelStatementBase> targets = getFallThroughTargets(body); retu... | mayFallThroughNonTerminalDefaultCase |
75,522 | void (@NotNull ActionContext context, @NotNull PsiSwitchStatement statement, @NotNull ModPsiUpdater updater) { doProcessIntention(statement); } | invoke |
75,523 | void (@NotNull PsiSwitchStatement switchStatement) { final PsiExpression switchExpression = switchStatement.getExpression(); if (switchExpression == null) { return; } final PsiType switchExpressionType = CommonJavaRefactoringUtil.getTypeByExpressionWithExpectedType(switchExpression); if (switchExpressionType == null) {... | doProcessIntention |
75,524 | boolean (@NotNull List<SwitchStatementBranch> allBranches) { return ContainerUtil.or(allBranches, br -> ContainerUtil.or(br.getCaseElements(), el -> el.element() instanceof PsiExpression expr && ExpressionUtils.isNullLiteral(expr))); } | hasNullCase |
75,525 | List<SwitchStatementBranch> (PsiCodeBlock body, Set<PsiSwitchLabelStatementBase> fallThroughTargets) { final List<SwitchStatementBranch> openBranches = new ArrayList<>(); final Set<PsiElement> declaredElements = new HashSet<>(); final List<SwitchStatementBranch> allBranches = new ArrayList<>(); SwitchStatementBranch cu... | extractBranches |
75,526 | Set<PsiSwitchLabelStatementBase> (PsiCodeBlock body) { return StreamEx.of(body.getStatements()) .pairMap((s1, s2) -> s2 instanceof PsiSwitchLabelStatement labelStatement && !(s1 instanceof PsiSwitchLabeledRuleStatement) && ControlFlowUtils.statementMayCompleteNormally(s1) ? labelStatement : null) .nonNull().collect(Col... | getFallThroughTargets |
75,527 | void (SwitchStatementBranch branch, String expressionText, boolean firstBranch, boolean useEquals, boolean useRequireNonNullMethod, @NonNls StringBuilder out, CommentTracker commentTracker) { if (!firstBranch) { out.append("else "); } dumpCaseValues(expressionText, branch.getCaseElements(), firstBranch, useEquals, useR... | dumpBranch |
75,528 | void (String expressionText, List<SwitchStatementBranch.LabelElement> caseElements, boolean firstBranch, boolean useEquals, boolean useRequireNonNullMethod, CommentTracker commentTracker, @NonNls StringBuilder out) { out.append("if("); boolean firstCaseValue = true; for (SwitchStatementBranch.LabelElement element : cas... | dumpCaseValues |
75,529 | String (PsiDeconstructionPattern deconstructionPattern, String expressionText, CommentTracker commentTracker) { return expressionText + " instanceof " + commentTracker.text(deconstructionPattern); } | createIfCondition |
75,530 | String (@Nullable PsiExpression value, @NotNull CommentTracker commentTracker) { if (value == null) { return ""; } if (!(value instanceof PsiReferenceExpression referenceExpression)) { return commentTracker.text(value); } final PsiElement target = referenceExpression.resolve(); if (!(target instanceof PsiEnumConstant e... | getCaseValueText |
75,531 | void (SwitchStatementBranch branch, @NonNls StringBuilder out, CommentTracker commentTracker) { final List<PsiElement> bodyStatements = branch.getBodyElements(); out.append('{'); if (!bodyStatements.isEmpty()) { PsiElement firstBodyElement = bodyStatements.get(0); PsiElement prev = PsiTreeUtil.skipWhitespacesAndComment... | dumpBody |
75,532 | Priority () { return PriorityAction.Priority.TOP; } | getPriority |
75,533 | boolean (@NotNull Project project, Editor editor, @NotNull PsiFile file) { if (myClassesToImport.length == 0) return false; return isStillAvailable() && !getClassesToImport(true).isEmpty(); } | isAvailable |
75,534 | boolean () { if (!isPsiModificationStampChanged()) { return true; } if (abortOnPSIModification) return false; // ok, something did change. but can we still import? (in case of auto-import there maybe multiple fixes wanting to be executed) List<? extends PsiClass> classesToImport = getClassesToImport(true); return class... | isStillAvailable |
75,535 | boolean (@NotNull PsiFile containingFile, @NotNull PsiClass classToImport) { return false; } | isClassMaybeImportedAlready |
75,536 | R () { return myReference; } | getReference |
75,537 | boolean (@NotNull PsiFile placeFile, @NotNull PsiClass aClass) { if (JavaCompletionUtil.isInExcludedPackage(aClass, false)) { return false; } String qName = aClass.getQualifiedName(); if (qName != null) { //filter local classes if (qName.indexOf('.') == -1 || !PsiNameHelper.getInstance(placeFile.getProject()).isQualifi... | qualifiedNameAllowsAutoImport |
75,538 | void (@NotNull Collection<PsiClass> classList, @NotNull PsiFile file) { String packageName = StringUtil.getPackageName(getQualifiedName(myReferenceElement)); if (!packageName.isEmpty() && file instanceof PsiJavaFile && !ArrayUtil.contains(packageName, ((PsiJavaFile)file).getImplicitlyImportedPackages())) { classList.re... | filerByPackageName |
75,539 | boolean (@NotNull R ref) { return true; } | canReferenceClass |
75,540 | void (@NotNull List<PsiClass> classList) { String memberName = getRequiredMemberName(myReferenceElement); if (memberName != null) { classList.removeIf(psiClass -> { PsiField field = psiClass.findFieldByName(memberName, true); if (field != null && field.hasModifierProperty(PsiModifier.STATIC) && isAccessible(field, myRe... | filterByRequiredMemberName |
75,541 | void (@NotNull Collection<PsiClass> list, @NotNull PsiFile containingFile) { if (!(containingFile instanceof PsiJavaFile javaFile)) return; PsiImportList importList = javaFile.getImportList(); PsiImportStatementBase[] importStatements = importList == null ? PsiImportStatementBase.EMPTY_ARRAY : importList.getAllImportSt... | filterAlreadyImportedButUnresolved |
75,542 | String (@NotNull T referenceElement) { return null; } | getRequiredMemberName |
75,543 | Collection<PsiClass> (@NotNull Collection<PsiClass> candidates, @NotNull T referenceElement) { return candidates; } | filterByContext |
75,544 | Collection<PsiClass> (@NotNull PsiType type, @NotNull Collection<PsiClass> candidates) { PsiClass actualClass = PsiUtil.resolveClassInClassTypeOnly(type); if (actualClass != null) { return ContainerUtil.findAll(candidates, psiClass -> InheritanceUtil.isInheritorOrSelf(actualClass, psiClass, true)); } return candidates;... | filterAssignableFrom |
75,545 | Collection<PsiClass> (@NotNull PsiParameter parameter, @NotNull Collection<PsiClass> candidates) { PsiElement parent = parameter.getParent(); if (parent instanceof PsiParameterList) { PsiElement granny = parent.getParent(); if (granny instanceof PsiMethod method && method.getModifierList().hasAnnotation(CommonClassName... | filterBySuperMethods |
75,546 | Result (@NotNull Editor editor, boolean allowPopup, boolean allowCaretNearRef, boolean mayAddUnambiguousImportsSilently) { ThreadingAssertions.assertEventDispatchThread(); List<? extends PsiClass> result = getClassesToImport(); PsiClass[] classes = result.toArray(PsiClass.EMPTY_ARRAY); if (classes.length == 0) return R... | doFix |
75,547 | boolean () { try { String name = getQualifiedName(myReferenceElement); if (name != null) { Pattern pattern = Pattern.compile(DaemonCodeAnalyzerSettings.getInstance().NO_AUTO_IMPORT_PATTERN); Matcher matcher = pattern.matcher(name); if (matcher.matches()) { return true; } } } catch (PatternSyntaxException e) { //ignore ... | isReferenceNameForbiddenForAutoImport |
75,548 | int (@NotNull T element, @NotNull R ref) { return element.getTextOffset(); } | getStartOffset |
75,549 | int (@NotNull T element, @NotNull R ref) { return element.getTextRange().getEndOffset(); } | getEndOffset |
75,550 | boolean (@NotNull PsiClass aClass) { PsiClass containingClass = aClass.getContainingClass(); // when importing inner class, the reference might be qualified with the outer class name, and it can be confusing return containingClass != null && !CodeStyle.getSettings(myContainingFile).getCustomSettings(JavaCodeStyleSettin... | autoImportWillInsertUnexpectedCharacters |
75,551 | boolean (boolean allowCaretNearRef, @NotNull Editor editor) { return (allowCaretNearRef || !isCaretNearRef(editor, myReference)) && !myHasUnresolvedImportWhichCanImport; } | canImportHere |
75,552 | boolean (@NotNull Editor editor) { if (isQualified(myReference)) { return false; } PsiFile file = myReferenceElement.isValid() && myContainingFile != null && myContainingFile.isValid() ? myContainingFile : null; if (file == null) return false; Result result = doFix(editor, true, false, ShowAutoImportPass.mayAutoImportN... | showHint |
75,553 | String () { return QuickFixBundle.message("import.class.fix"); } | getText |
75,554 | String () { return QuickFixBundle.message("import.class.fix"); } | getFamilyName |
75,555 | boolean () { return false; } | startInWriteAction |
75,556 | void (@NotNull List<PsiClass> classes, @NotNull PsiFile file) { Project project = file.getProject(); DependencyValidationManager validationManager = DependencyValidationManager.getInstance(project); for (int i = classes.size() - 1; i >= 0; i--) { PsiClass psiClass = classes.get(i); PsiFile targetFile = psiClass.getCont... | reduceSuggestedClassesBasedOnDependencyRuleViolation |
75,557 | boolean (@NotNull Editor editor, @NotNull R ref) { PsiElement nameElement = getReferenceNameElement(ref); if (nameElement == null) return false; TextRange range = nameElement.getTextRange(); int offset = editor.getCaretModel().getOffset(); return offset == range.getEndOffset(); } | isCaretNearRef |
75,558 | void (@NotNull Project project, Editor editor, PsiFile file) { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; ApplicationManager.getApplication().runWriteAction(() -> { if (!isStillAvailable()) return; PsiClass[] classes = getClassesToImport(true).toArray(PsiClass.EMPTY_ARRAY); if (classe... | invoke |
75,559 | void (@NotNull PsiReference reference, @NotNull PsiClass targetClass) { reference.bindToElement(targetClass); } | bindReference |
75,560 | AddImportAction (PsiClass @NotNull [] classes, @NotNull Project project, @NotNull Editor editor) { return new AddImportAction(project, myReference, editor, classes) { @Override protected void bindReference(@NotNull PsiReference ref, @NotNull PsiClass targetClass) { ImportClassFixBase.this.bindReference(ref, targetClass... | createAddImportAction |
75,561 | void (@NotNull PsiReference ref, @NotNull PsiClass targetClass) { ImportClassFixBase.this.bindReference(ref, targetClass); } | bindReference |
75,562 | void () { abortOnPSIModification = false; } | surviveOnPSIModifications |
75,563 | String (String varName) { return getMessage(varName); } | getText |
75,564 | boolean (int offset) { if (!super.isAvailableImpl(offset)) return false; if(myReferenceExpression.isQualified()) return false; PsiStatement anchor = getAnchor(myReferenceExpression); if (anchor == null) return false; if (anchor instanceof PsiExpressionStatement) { PsiExpression expression = ((PsiExpressionStatement)anc... | isAvailableImpl |
75,565 | boolean () { return true; } | startInWriteAction |
75,566 | void (@NotNull Project project, Editor editor, PsiFile file) { String varName = myReferenceExpression.getReferenceName(); if (CreateFromUsageUtils.isValidReference(myReferenceExpression, false) || varName == null) return; if (file.isPhysical()) { IdeDocumentHistory.getInstance(project).includeCurrentPlaceAsChangePlace(... | invoke |
75,567 | void (@NotNull Template template, boolean brokenOff) { PsiDocumentManager.getInstance(project).commitDocument(newEditor.getDocument()); final int offset = newEditor.getCaretModel().getOffset(); final PsiLocalVariable localVariable = PsiTreeUtil.findElementOfClassAtOffset(file, offset, PsiLocalVariable.class, false); if... | templateFinished |
75,568 | boolean () { return false; } | isAllowOuterTargetClass |
75,569 | PsiStatement (PsiExpression... expressionOccurrences) { PsiElement parent = expressionOccurrences[0]; int minOffset = expressionOccurrences[0].getTextRange().getStartOffset(); for (int i = 1; i < expressionOccurrences.length; i++) { parent = PsiTreeUtil.findCommonParent(parent, expressionOccurrences[i]); LOG.assertTrue... | getAnchor |
75,570 | String () { return QuickFixBundle.message("create.local.from.usage.family"); } | getFamilyName |
75,571 | PsiMethod (final String methodText, final PsiClass implClass) { return JavaPsiFacade.getElementFactory(implClass.getProject()).createMethodFromText(methodText, implClass); } | createMethod |
75,572 | String () { return QuickFixBundle.message("add.method.family"); } | getFamilyName |
75,573 | void (@NotNull ActionContext context, @NotNull PsiClass psiClass, @NotNull ModPsiUpdater updater) { PsiMethod method = createMethod(psiClass); if (method.getContainingFile().getOriginalFile() == context.file()) { GenerateMembersUtil.positionCaret(updater, method, true); } } | invoke |
75,574 | PsiMethod (@NotNull PsiClass psiClass) { PsiMethod methodPrototype = myMethodPrototype.getElement(); if (methodPrototype == null) return null; PsiCodeBlock body; if (psiClass.isInterface() && (body = methodPrototype.getBody()) != null) body.delete(); for (String exception : myExceptions) { PsiUtil.addException(methodPr... | createMethod |
75,575 | String () { return QuickFixBundle.message("defer.final.assignment.with.temp.family"); } | getFamilyName |
75,576 | void (@NotNull ActionContext context, @NotNull PsiVariable variable, @NotNull ModPsiUpdater updater) { if (variable instanceof PsiField field) { PsiCodeBlock codeBlock = getEnclosingCodeBlock(field, updater.getWritable(expression)); if (codeBlock == null) return; deferVariable(codeBlock, variable, null, updater); } els... | invoke |
75,577 | PsiCodeBlock (PsiField field, PsiElement element) { PsiClass aClass = field.getContainingClass(); if (aClass == null) return null; PsiMethod[] constructors = aClass.getConstructors(); for (PsiMethod constructor : constructors) { PsiCodeBlock body = constructor.getBody(); if (body == null) continue; if (PsiTreeUtil.isAn... | getEnclosingCodeBlock |
75,578 | void (PsiElement context, final PsiVariable variable, final List<? super PsiReferenceExpression> references) { context.accept(new JavaRecursiveElementWalkingVisitor() { @Override public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) { if (expression.resolve() == variable) references.add(expre... | collectReferences |
75,579 | String () { return myText; } | getFamilyName |
75,580 | ModCommand (@NotNull ActionContext context, @NotNull NavigatablePsiElement element) { if (element instanceof PsiNameIdentifierOwner owner) { PsiElement identifier = owner.getNameIdentifier(); if (identifier != null) { return ModCommand.select(identifier); } } return ModCommand.select(element); } | perform |
75,581 | String () { return QuickFixBundle.message("remove.unused.element.family", JavaElementKind.VARIABLE.object()); } | getFamilyName |
75,582 | ModCommand (@NotNull ActionContext context, @NotNull PsiVariable variable) { final List<PsiReferenceExpression> references = collectReferences(variable); Map<PsiExpression, List<PsiExpression>> effects = collectSideEffects(variable, references); if (effects.isEmpty()) { return new RemoveVariableSideEffectAware(variable... | perform |
75,583 | String () { return myKeepSideEffects ? JavaBundle.message("intention.family.name.extract.possible.side.effects") : JavaBundle.message("intention.family.name.delete.possible.side.effects"); } | getFamilyName |
75,584 | void (@NotNull ActionContext context, @NotNull PsiVariable variable, @NotNull ModPsiUpdater updater) { boolean retry = true; while(retry) { retry = false; List<PsiReferenceExpression> refs = collectReferences(variable); for (PsiReferenceExpression ref : refs) { if (!ref.isValid()) { retry = true; break; } PsiElement pa... | invoke |
75,585 | List<PsiReferenceExpression> (@NotNull PsiVariable variable) { PsiElement context = variable instanceof PsiField ? ((PsiField)variable).getContainingClass() : PsiUtil.getVariableCodeBlock(variable, null); List<PsiReferenceExpression> references = new ArrayList<>(VariableAccessUtils.getVariableReferences(variable, conte... | collectReferences |
75,586 | PsiType (@NotNull PsiMethod method, @NotNull PsiType returnType) { if (TypeConversionUtil.isNullType(returnType)) { returnType = PsiType.getJavaLangObject(method.getManager(), method.getResolveScope()); } return returnType; } | correctType |
75,587 | String () { if (!mySuggestSuperTypes) return QuickFixBundle.message("fix.return.type.text", myDisplayName, myCanonicalText); PsiType type = Objects.requireNonNull(myReturnTypePointer.getType()); boolean hasPredecessor = type.getSuperTypes().length != 0; return QuickFixBundle.message(hasPredecessor ? "fix.return.type.or... | getText |
75,588 | String () { return QuickFixBundle.message("fix.return.type.family"); } | getFamilyName |
75,589 | boolean (@NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { final PsiMethod method = (PsiMethod)startElement; if(!method.isPhysical()) return false; final PsiType newType = myReturnTypePointer.getType(); if (BaseIntentionAction.canModify(method) && newTy... | isAvailable |
75,590 | void (@NotNull Project project, @NotNull PsiFile file, Editor editor, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { final PsiMethod method = (PsiMethod)startElement; if (!FileModificationService.getInstance().prepareFileForWrite(method.getContainingFile())) return; PsiType newType = myReturnTypePo... | invoke |
75,591 | Set<PsiType> (PsiType type, PsiElement context, Set<PsiType> result) { final PsiType[] superTypes = type.getSuperTypes(); if (superTypes.length == 0 && type instanceof PsiArrayType) { final Project project = context.getProject(); final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); result.add(fac... | collectSuperTypes |
75,592 | void (@NotNull Project project, @NotNull PsiMethod myMethod, @NotNull PsiType myReturnType) { PsiTypeElement typeElement = PsiElementFactory.getInstance(project).createTypeElement(myReturnType); myMethod.addBefore(typeElement, myMethod.getNameIdentifier()); } | addReturnType |
75,593 | List<PsiType> (PsiType @NotNull [] types, @NotNull PsiType defaultType) { Map<String, PsiType> map = new LinkedHashMap<>(); String defaultTypeKey = serialize(defaultType); map.put(defaultTypeKey, defaultType); Arrays.stream(types).forEach(t -> map.put(serialize(t), t)); List<PsiType> ordered = new ArrayList<>(); Statis... | getReturnTypes |
75,594 | String (PsiType type) { if (PsiUtil.resolveClassInType(type) instanceof PsiTypeParameter) return type.getCanonicalText(); return TypeConversionUtil.erasure(type).getCanonicalText(); } | serialize |
75,595 | void (@NotNull Project project, @NotNull PsiFile file, @NotNull Editor editor, @NotNull List<PsiType> returnTypes, @NotNull PsiType myReturnType, @NotNull PsiMethod myMethod) { PsiTypeElement typeElement = myMethod.getReturnTypeElement(); if (typeElement == null) return; TemplateBuilderImpl builder = new TemplateBuilde... | selectReturnType |
75,596 | void (@NotNull Template template, boolean brokenOff) { if (brokenOff) return; PsiType newReturnType = myMethod.getReturnType(); if (newReturnType == null) return; TypeSelectorManagerImpl.typeSelected(newReturnType, myReturnType); changeReturnType(project, file, editor, myMethod, newReturnType); } | templateFinished |
75,597 | void (@NotNull Project project, @NotNull PsiFile file, Editor editor, @NotNull PsiMethod method, @NotNull PsiType returnType) { if (myFixWholeHierarchy) { final PsiMethod superMethod = method.findDeepestSuperMethod(); final PsiType superReturnType = superMethod == null ? null : superMethod.getReturnType(); if (superRet... | changeReturnType |
75,598 | PsiReturnStatement (PsiFile file, PsiMethod method) { final PsiModifierList modifiers = method.getModifierList(); if (modifiers.hasModifierProperty(PsiModifier.ABSTRACT) || method.getBody() == null) { return null; } try { final ConvertReturnStatementsVisitor visitor = new ConvertReturnStatementsVisitor(factory, method,... | addReturnForMethod |
75,599 | Editor (PsiMethod myMethod, @NotNull Project project, Editor editor, PsiFile file) { PsiFile containingFile = myMethod.getContainingFile(); if (containingFile != file) { OpenFileDescriptor descriptor = new OpenFileDescriptor(project, containingFile.getVirtualFile()); return FileEditorManager.getInstance(project).openTe... | getEditorForMethod |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.