Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
75,600 | PsiType (PsiMethod method, @NotNull PsiType returnType) { for (PsiMethod superMethod : method.findDeepestSuperMethods()) { PsiType superMethodReturnType = superMethod.getReturnType(); if (superMethodReturnType != null && superMethodReturnType.isAssignableFrom(returnType)) { if (superMethodReturnType instanceof PsiClass... | getHierarchyAdjustedReturnType |
75,601 | List<PsiMethod> (PsiMethod method, @NotNull PsiType returnType) { PsiMethod[] methods = new PsiMethod[] {method}; if (myFixWholeHierarchy) { PsiType type = getHierarchyAdjustedReturnType(method, returnType); if (type != null) { returnType = type; } else { final PsiMethod[] superMethods = method.findDeepestSuperMethods(... | changeReturnType |
75,602 | void (@Nullable PsiElement element, Editor editor) { LOG.assertTrue(element != null); TextRange range = element.getTextRange(); int offset = range.getStartOffset(); editor.getCaretModel().moveToOffset(offset); editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); editor.getSelectionModel().setSelection(range.g... | selectInEditor |
75,603 | boolean (PsiMethod myMethod, Project project, PsiType superReturnType, PsiClass superClass, Editor editor, PsiType returnType) { if (superClass == null || !superClass.hasTypeParameters()) return true; final PsiClass superReturnTypeClass = PsiUtil.resolveClassInType(superReturnType); if (superReturnTypeClass == null || ... | changeClassTypeArgument |
75,604 | PsiReferenceParameterList (PsiClass superClass, PsiClass derivedClass) { PsiReferenceParameterList referenceParameterList = null; if (derivedClass instanceof PsiAnonymousClass) { referenceParameterList = ((PsiAnonymousClass)derivedClass).getBaseClassReference().getParameterList(); } else { final PsiReferenceList implem... | findTypeArgumentsList |
75,605 | PsiReferenceParameterList (PsiClass superClass, PsiReferenceList extendsList) { for (PsiJavaCodeReferenceElement referenceElement : extendsList.getReferenceElements()) { final PsiElement element = referenceElement.resolve(); if (element instanceof PsiClass && InheritanceUtil.isInheritorOrSelf((PsiClass)element, superCl... | extractReferenceParameterList |
75,606 | boolean () { return false; } | startInWriteAction |
75,607 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { PsiType type = myReturnTypePointer.getType(); if (type == null) { return IntentionPreviewInfo.EMPTY; } PsiMethod method = (PsiMethod)getStartElement(); type = correctType(method, type); PsiFile containingFile = method.getCo... | generatePreview |
75,608 | void (@NotNull PsiMethod method, @NotNull PsiType type) { PsiTypeElement typeElement = method.getReturnTypeElement(); Project project = method.getProject(); if (typeElement != null) { JavaCodeStyleManager.getInstance(project) .shortenClassReferences(typeElement.replace(PsiElementFactory.getInstance(project).createTypeE... | updateMethodType |
75,609 | String () { return JavaBundle.message("qualify.static.constant.access"); } | getBaseText |
75,610 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { return generatePreview(file, (expression, field) -> { if (expression instanceof PsiReferenceExpression) { QualifyStaticMethodCallFix.qualifyStatically(field, project, (PsiReferenceExpression)expression); } }); } | generatePreview |
75,611 | QuestionAction (@NotNull List<? extends PsiField> fieldsToImport, @NotNull Project project, Editor editor) { return new StaticImportMemberQuestionAction<PsiField>(project, editor, fieldsToImport, myReferencePointer) { @NotNull @Override protected String getPopupTitle() { return QuickFixBundle.message("field.to.import.c... | createQuestionAction |
75,612 | String () { return QuickFixBundle.message("field.to.import.chooser.title"); } | getPopupTitle |
75,613 | void (@NotNull PsiField toImport) { PsiElement element = myReferencePointer.getElement(); if (!(element instanceof PsiReferenceExpression)) return; WriteCommandAction.runWriteCommandAction(project, JavaBundle.message("qualify.static.access.command.name"), null, () -> QualifyStaticMethodCallFix.qualifyStatically(toImpor... | doImport |
75,614 | boolean (int offset) { final PsiNameValuePair call = getNameValuePair(); if (call == null || !call.isValid()) return false; String name = call.getName(); if (name == null || !PsiNameHelper.getInstance(call.getProject()).isIdentifier(name)) return false; if (getAnnotationValueType(call.getValue()) == null) return false;... | isAvailableImpl |
75,615 | PsiElement () { final PsiNameValuePair call = getNameValuePair(); if (call == null || !call.getManager().isInProject(call)) return null; return call; } | getElement |
75,616 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { PsiNameValuePair nameValuePair = getNameValuePair(); List<PsiClass> classes = filterTargetClasses(nameValuePair, project); if (nameValuePair == null || classes.isEmpty()) return IntentionPreviewInfo.EMPTY; final PsiType typ... | generatePreview |
75,617 | void (@NotNull PsiClass targetClass) { PsiNameValuePair nameValuePair = getNameValuePair(); if (nameValuePair == null || isValidElement(nameValuePair)) return; final PsiElementFactory factory = JavaPsiFacade.getElementFactory(nameValuePair.getProject()); final String methodName = nameValuePair.getName(); LOG.assertTrue... | invokeImpl |
75,618 | PsiType (PsiAnnotationMemberValue value) { PsiType type = null; if (value instanceof PsiExpression) { type = ((PsiExpression)value).getType(); } else if (value instanceof PsiArrayInitializerMemberValue) { final PsiAnnotationMemberValue[] initializers = ((PsiArrayInitializerMemberValue)value).getInitializers(); PsiType ... | getAnnotationValueType |
75,619 | boolean (PsiElement element) { final PsiReference reference = element.getReference(); return reference != null && reference.resolve() != null; } | isValidElement |
75,620 | String () { return QuickFixBundle.message("create.method.from.usage.family"); } | getFamilyName |
75,621 | PsiNameValuePair () { return myNameValuePair.getElement(); } | getNameValuePair |
75,622 | String () { return QuickFixBundle.message("move.catch.up.family"); } | getFamilyName |
75,623 | ModCommand (@NotNull ActionContext context) { return ModCommand.psiUpdate(context, updater -> { PsiCatchSection catchSection = updater.getWritable(myCatchSection); PsiCatchSection moveBeforeSection = updater.getWritable(myMoveBeforeSection); PsiTryStatement statement = catchSection.getTryStatement(); statement.addBefor... | perform |
75,624 | String () { return QuickFixBundle.message("convert.primitive.to.boxed.type"); } | getFamilyName |
75,625 | void (@NotNull ActionContext context, @NotNull PsiTypeElement typeElement, @NotNull ModPsiUpdater updater) { final PsiType type = typeElement.getType(); PsiType boxedType; if (type instanceof PsiPrimitiveType primitiveType) { boxedType = primitiveType.getBoxedType(typeElement); } else { LOG.assertTrue(type instanceof P... | invoke |
75,626 | void (@NotNull ActionContext context, @NotNull PsiErrorElement element, @NotNull ModPsiUpdater updater) { PsiFile file = element.getContainingFile(); MemberInfo rangeAndMember = createMember(file, element); if (rangeAndMember == null) return; Document document = file.getViewProvider().getDocument(); TextRange memberRan... | invoke |
75,627 | PsiClass (@NotNull PsiFile file, @NotNull PsiMember member) { String className = FileUtilRt.getNameWithoutExtension(file.getName()); if (!StringUtil.isJavaIdentifier(className)) return null; PsiJavaFile javaFile = ObjectUtils.tryCast(file, PsiJavaFile.class); if (javaFile == null) return null; PsiClass psiClass = Conta... | getPsiClass |
75,628 | String () { return JavaBundle.message("intention.family.name.move.member.into.class"); } | getFamilyName |
75,629 | PsiClass (@NotNull PsiElementFactory factory, @NotNull String className, @NotNull PsiMember member) { PsiMethod psiMethod = ObjectUtils.tryCast(member, PsiMethod.class); if (psiMethod == null || psiMethod.getBody() != null || psiMethod.hasModifier(JvmModifier.NATIVE)) { return factory.createClass(className); } if (psiM... | createClass |
75,630 | IntentionPreviewInfo (ActionContext context, PsiErrorElement element) { MemberInfo info = createMember(context.file(), element); if (info == null || !(info.member() instanceof PsiNamedElement member)) return IntentionPreviewInfo.EMPTY; PsiClass psiClass = getPsiClass(context.file(), info.member()); if (psiClass == null... | generatePreview |
75,631 | boolean (PsiReference reference, boolean unresolvedOnly) { if (!(reference instanceof PsiJavaReference)) return false; JavaResolveResult[] results = ((PsiJavaReference)reference).multiResolve(false); if(results.length == 0) return false; if (!unresolvedOnly) { for (JavaResolveResult result : results) { if (!result.isVa... | isValidReference |
75,632 | boolean (PsiReference reference, PsiMethodCallExpression call) { if (!(reference instanceof PsiJavaReference)) return false; try { JavaResolveResult candidate = ((PsiJavaReference) reference).advancedResolve(false); PsiElement result = candidate.getElement(); return result instanceof PsiMethod && PsiUtil.isApplicable((... | isValidMethodReference |
75,633 | void (@NotNull PsiMethod method, @NotNull Editor newEditor) { PsiCodeBlock body = method.getBody(); if (body != null) { setupEditor(body, newEditor); } } | setupEditor |
75,634 | void (@NotNull PsiCodeBlock body, @NotNull Editor newEditor) { PsiElement l = PsiTreeUtil.skipWhitespacesForward(body.getLBrace()); PsiElement r = PsiTreeUtil.skipWhitespacesBackward(body.getRBrace()); if (l != null && r != null) { int start = l.getTextRange().getStartOffset(); int end = r.getTextRange().getEndOffset()... | setupEditor |
75,635 | void (@NotNull PsiCodeBlock body, @NotNull ModPsiUpdater updater) { PsiElement l = PsiTreeUtil.skipWhitespacesForward(body.getLBrace()); PsiElement r = PsiTreeUtil.skipWhitespacesBackward(body.getRBrace()); if (l != null && r != null) { int start = l.getTextRange().getStartOffset(); int end = r.getTextRange().getEndOff... | setupEditor |
75,636 | void (final PsiMethod method, final TemplateBuilder builder, final PsiElement contextElement, final PsiSubstitutor substitutor, final PsiExpression[] arguments) { setupMethodParameters(method, builder, contextElement, substitutor, ContainerUtil.map(arguments, arg -> new Pair<>(arg, null))); } | setupMethodParameters |
75,637 | PsiType (@Nullable PsiType argType, @NotNull PsiManager psiManager, @NotNull GlobalSearchScope resolveScope) { if (argType instanceof PsiDisjunctionType) { argType = ((PsiDisjunctionType)argType).getLeastUpperBound(); } else if (argType instanceof PsiWildcardType) { argType = ((PsiWildcardType)argType).getBound(); } if... | getParameterTypeByArgumentType |
75,638 | PsiClass (final PsiJavaCodeReferenceElement referenceElement, final CreateClassKind classKind, final String superClassName) { assert !ApplicationManager.getApplication().isWriteAccessAllowed() : "You must not run createClass() from under write action"; final String name = referenceElement.getReferenceName(); String qua... | createClass |
75,639 | boolean () { return true; } | reportBaseInSourceSelectionInTest |
75,640 | PsiPackage (PsiElement qualifierElement, PsiManager manager, PsiFile sourceFile) { PsiPackage aPackage = null; if (qualifierElement instanceof PsiPackage) { aPackage = (PsiPackage)qualifierElement; } else { final PsiDirectory directory = sourceFile.getContainingDirectory(); if (directory != null) { aPackage = JavaDirec... | findTargetPackage |
75,641 | PsiClass (PsiClass psiClass, CreateClassKind classKind, String name, PsiJavaCodeReferenceElement referenceElement, @Nullable String superClassName) { PsiManager manager = psiClass.getManager(); PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(manager.getProject()); PsiClass result = classKind == Creat... | createClassInQualifier |
75,642 | PsiClass (final CreateClassKind classKind, final PsiDirectory directory, final String name, final PsiManager manager, @NotNull final PsiElement contextElement, final PsiFile sourceFile, final String superClassName) { final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); final PsiElementFactory f... | createClass |
75,643 | void (PsiClass targetClass, String superClassName) { JavaPsiFacade facade = JavaPsiFacade.getInstance(targetClass.getProject()); PsiElementFactory factory = facade.getElementFactory(); final PsiClass superClass = facade.findClass(superClassName, targetClass.getResolveScope()); final PsiJavaCodeReferenceElement superCla... | setupSuperClassReference |
75,644 | void (final IncorrectOperationException e, final String name, final PsiDirectory directory, final boolean isPackage) { ApplicationManager.getApplication().invokeLater(() -> Messages.showErrorDialog(QuickFixBundle.message( isPackage ? "cannot.create.java.package.error.text" : "cannot.create.java.file.error.text", name, ... | scheduleFileOrPackageCreationFailedMessageBox |
75,645 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if(!(element instanceof PsiField) || JavaPsiFacade.getInstance(element.getProject()).getResolveHelper().isAccessible((PsiField)element, expression, null)) { return super.execute(element, state); } return true; } | execute |
75,646 | void (final PsiExpression expression, List<ExpectedTypeInfo[]> types, List<? super String> expectedMethodNames, List<? super String> expectedFieldNames) { Comparator<ExpectedTypeInfo> expectedTypesComparator = (o1, o2) -> compareExpectedTypes(o1, o2, expression); for (PsiExpression expr : collectExpressions(expression,... | getExpectedInformation |
75,647 | int (ExpectedTypeInfo o1, ExpectedTypeInfo o2, PsiExpression expression) { PsiClass c1 = PsiUtil.resolveClassInType(o1.getDefaultType()); PsiClass c2 = PsiUtil.resolveClassInType(o2.getDefaultType()); if (c1 == null && c2 == null) return 0; if (c1 == null || c2 == null) return c1 == null ? -1 : 1; return compareMembers... | compareExpectedTypes |
75,648 | PsiType (@NotNull PsiType type) { if (PsiTypes.nullType().equals(type) || PsiTypes.voidType().equals(type) && !allowVoidType) { type = PsiType.getJavaLangObject(manager, resolveScope); } if (!typesSet.contains(type)) { if (type instanceof PsiClassType && (!expectedFieldNames.isEmpty() || !expectedMethodNames.isEmpty())... | visitType |
75,649 | PsiType (@NotNull PsiCapturedWildcardType capturedWildcardType) { return capturedWildcardType.getUpperBound().accept(this); } | visitCapturedWildcardType |
75,650 | void (PsiMember[] members, final PsiExpression expression, List<ExpectedTypeInfo[]> types, PsiElementFactory factory) { Arrays.sort(members, (m1, m2) -> compareMembers(m1, m2, expression)); List<ExpectedTypeInfo> l = new ArrayList<>(); PsiManager manager = expression.getManager(); JavaPsiFacade facade = JavaPsiFacade.g... | addMemberInfo |
75,651 | int (PsiMember m1, PsiMember m2, PsiExpression context) { ProgressManager.checkCanceled(); final StatisticsManager m = StatisticsManager.getInstance(); int result = m.getUseCount(JavaStatisticsManager.createInfo(null, m2)) - m.getUseCount(JavaStatisticsManager.createInfo(null, m1)); if (result != 0) return result; fina... | compareMembers |
75,652 | boolean (final PsiExpression[] expressionOccurrences) { for (PsiExpression expression : expressionOccurrences) { if(expression.isValid() && PsiUtil.isAccessedForWriting(expression)) return true; } return false; } | isAccessedForWriting |
75,653 | boolean (int offset, PsiElement namedElement, PsiElement element) { if (namedElement == null) return false; TextRange range = namedElement.getTextRange(); if (range.getLength() == 0) return false; boolean isInNamedElement = range.contains(offset); return isInNamedElement || element.getTextRange().contains(offset-1); } | shouldShowTag |
75,654 | void (final String memberName, final PsiFile file, final Set<? super String> possibleClassNames, final boolean method, final boolean staticAccess) { addClassesWithMember(memberName, file, possibleClassNames, method, staticAccess, true); } | addClassesWithMember |
75,655 | void (final String memberName, final PsiFile file, final Set<? super String> possibleClassNames, final boolean method, final boolean staticAccess, final boolean addObjectInheritors) { final Project project = file.getProject(); final Module moduleForFile = ModuleUtilCore.findModuleForPsiElement(file); if (moduleForFile ... | addClassesWithMember |
75,656 | boolean (Set<? super String> possibleClassNames, final JavaPsiFacade facade, final GlobalSearchScope searchScope, final boolean method, final String memberName, final boolean staticAccess, boolean addInheritors) { final PsiShortNamesCache cache = PsiShortNamesCache.getInstance(facade.getProject()); final boolean[] allC... | handleObjectMethod |
75,657 | String (final PsiClass aClass) { return ReadAction.compute(aClass::getQualifiedName); } | getQualifiedName |
75,658 | boolean (@Nullable final PsiMember member, final boolean staticAccess) { if (member == null) { return false; } return ReadAction.compute(() -> !member.hasModifierProperty(PsiModifier.PRIVATE) && member.hasModifierProperty(PsiModifier.STATIC) == staticAccess).booleanValue(); } | hasCorrectModifiers |
75,659 | Result (ExpressionContext context) { LookupElement[] lookupItems = calculateLookupItems(context); if (lookupItems.length == 0) return new TextResult(""); return new TextResult(lookupItems[0].getLookupString()); } | calculateResult |
75,660 | Result (ExpressionContext context) { return null; } | calculateQuickResult |
75,661 | Set<String> (PsiElement elementAt) { PsiElement parameterList = PsiTreeUtil.getParentOfType(elementAt, PsiParameterList.class, PsiRecordHeader.class); if (parameterList == null) { if (elementAt == null) return null; final PsiElement parent = elementAt.getParent(); if (!(parent instanceof PsiMethod)) return null; parame... | getPeerNames |
75,662 | LookupFocusDegree () { return LookupFocusDegree.UNFOCUSED; } | getLookupFocusDegree |
75,663 | String () { return QuickFixBundle.message("initialize.final.field.in.constructor.name"); } | getFamilyName |
75,664 | ModCommand (@NotNull ActionContext context, @NotNull PsiField field) { final PsiClass myClass = field.getContainingClass(); if (myClass == null) return ModCommand.nop(); if (myClass.getConstructors().length == 0) { return ModCommand.psiUpdate(context, updater -> { PsiClass writableClass = updater.getWritable(myClass); ... | perform |
75,665 | ModCommand (@NotNull PsiField field, List<? extends @NotNull MemberChooserElement> chosenMembers) { return ModCommand.psiUpdate(field, (writableField, updater) -> { List<PsiMethod> writableConstructors = ContainerUtil.map(chosenMembers, member -> updater.getWritable(((PsiMethodMember)member).getElement())); addFieldIni... | getFinalCommand |
75,666 | void (@NotNull List<? extends PsiMethod> constructors, @NotNull PsiField field, @NotNull ModPsiUpdater updater) { Project project = field.getProject(); if (constructors.isEmpty()) return; final LookupElement[] suggestedInitializers = AddVariableInitializerFix.suggestInitializer(field); final List<SmartPsiElementPointer... | addFieldInitialization |
75,667 | void (@NotNull final List<? extends PsiExpression> initializers, final LookupElement @NotNull [] suggestedInitializers, @NotNull ModPsiUpdater updater) { LOG.assertTrue(!initializers.isEmpty()); final PsiExpression initializer = Objects.requireNonNull(ContainerUtil.getFirstItem(initializers)); PsiElement context = init... | runAssignmentTemplate |
75,668 | PsiExpression (@NotNull PsiMethod constructor, LookupElement @NotNull [] suggestedInitializers, @NotNull PsiField field, @NotNull Project project) { PsiCodeBlock methodBody = constructor.getBody(); if (methodBody == null) { //incomplete code CreateFromUsageUtils.setupMethodBody(constructor); methodBody = constructor.ge... | addFieldInitialization |
75,669 | boolean (@NotNull PsiMethod constructor, @NotNull String name) { return ContainerUtil.exists(constructor.getParameterList().getParameters(), parameter -> name.equals(parameter.getName())); } | methodContainsParameterWithName |
75,670 | String (String varName) { return CommonQuickFixBundle.message("fix.create.title.x", JavaElementKind.FIELD.object(), varName); } | getText |
75,671 | List<PsiClass> (PsiElement element) { final List<PsiClass> targetClasses = new ArrayList<>(); for (PsiClass psiClass : super.getTargetClasses(element)) { if (canModify(psiClass) && (!psiClass.isInterface() && !psiClass.isAnnotationType() && !psiClass.isRecord() || shouldCreateStaticMember(myReferenceExpression, psiClas... | getTargetClasses |
75,672 | boolean (PsiClass psiClass) { return canModify(psiClass) && !psiClass.isInterface() && !psiClass.isAnnotationType() && !psiClass.isRecord(); } | canBeTargetClass |
75,673 | void (@NotNull PsiClass targetClass) { final Project project = myReferenceExpression.getProject(); JVMElementFactory factory = JVMElementFactories.getFactory(targetClass.getLanguage(), project); if (factory == null) factory = JavaPsiFacade.getElementFactory(project); PsiMember enclosingContext = null; PsiClass parentCl... | invokeImpl |
75,674 | void (final PsiClass targetClass, final Project project, final Object expectedTypes, final PsiField field, final boolean createConstantField, final PsiElement context) { final PsiFile targetFile = targetClass.getContainingFile(); final Editor newEditor = CodeInsightUtil.positionCursor(project, targetFile, field); if (n... | createFieldFromUsageTemplate |
75,675 | void (@NotNull Template template, boolean brokenOff) { PsiDocumentManager.getInstance(project).commitDocument(newEditor.getDocument()); final int offset = newEditor.getCaretModel().getOffset(); final PsiField psiField = PsiTreeUtil.findElementOfClassAtOffset(targetFile, offset, PsiField.class, false); if (psiField != n... | templateFinished |
75,676 | boolean (@NotNull PsiReferenceExpression ref, @NotNull PsiClass targetClass) { if (!PsiTreeUtil.isAncestor(targetClass, ref, true)) { return false; } final PsiElement element = PsiTreeUtil.getParentOfType(ref, PsiClassInitializer.class, PsiMethod.class, PsiField.class); if (element instanceof PsiClassInitializer) { ret... | shouldCreateFinalMember |
75,677 | String () { return QuickFixBundle.message("create.field.from.usage.family"); } | getFamilyName |
75,678 | String () { return QuickFixBundle.message("add.0.to.classpath", myLibraryDescriptor.getPresentableName()); } | getText |
75,679 | String () { return getText(); } | getFamilyName |
75,680 | boolean (@NotNull Project project, @Nullable Editor editor, PsiFile file) { return !project.isDisposed() && !myCurrentModule.isDisposed(); } | isAvailable |
75,681 | IntentionPreviewInfo (@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { if (myQualifiedClassName == null) { return new IntentionPreviewInfo.Html( HtmlChunk.text( JavaBundle.message("adds.ext.library.preview", myLibraryDescriptor.getPresentableName(), myCurrentModule.getName()))); } else { retur... | generatePreview |
75,682 | void (ItemEvent e) { updateButtons(); } | itemStateChanged |
75,683 | void (@NotNull DocumentEvent e) { updateButtons(); } | textChanged |
75,684 | List<String> () { if (ApplicationManager.getApplication().isHeadlessEnvironment()) { Disposer.dispose(myDisposable); return myDefaultLibraryPaths; } return showAndGet() ? getResultingLibraryPaths() : Collections.emptyList(); } | showAndGetResult |
75,685 | List<String> () { return myResultingLibraryPaths; } | getResultingLibraryPaths |
75,686 | void () { final boolean copyFiles = myCopyLibraryFilesRadioButton.isSelected(); myCopyToDir.setEnabled(copyFiles); setOKActionEnabled(!copyFiles || !myCopyToDir.getText().isEmpty()); } | updateButtons |
75,687 | String () { return "#com.intellij.codeInsight.daemon.impl.quickfix.LocateLibraryDialog"; } | getDimensionServiceKey |
75,688 | JComponent () { return myUseBundledRadioButton; } | getPreferredFocusedComponent |
75,689 | JComponent () { return myContentPane; } | createCenterPanel |
75,690 | void () { if (getOKAction().isEnabled()) { myResultingLibraryPaths = computeResultingPaths(); if (!myResultingLibraryPaths.isEmpty()) { close(OK_EXIT_CODE); } } } | doOKAction |
75,691 | List<String> () { if (myUseBundledRadioButton.isSelected()) { return myDefaultLibraryPaths; } final String dstDir = myCopyToDir.getText(); if (dstDir.isEmpty()) { return Collections.emptyList(); } List<String> result = new ArrayList<>(); for (String path : myDefaultLibraryPaths) { final File srcFile = new File(path); i... | computeResultingPaths |
75,692 | boolean () { return false; } | startInWriteAction |
75,693 | PsiJavaCodeReferenceElement (@NotNull PsiJavaCodeReferenceElement referenceElement) { PsiElement parent = referenceElement.getParent(); while (parent instanceof PsiJavaCodeReferenceElement) { referenceElement = (PsiJavaCodeReferenceElement)parent; parent = parent.getParent(); } return referenceElement; } | findTopmostReference |
75,694 | boolean (@NotNull String classFQN, @NotNull Project project) { JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); PsiManager psiManager = PsiManager.getInstance(project); String qualifierText = StringUtil.getPackageName(classFQN); PsiClass outerClass = psiFacade.findClass(qualifierText, GlobalSearchScope.pro... | isQualifierInProject |
75,695 | PsiClass (@NotNull String name, @NotNull PsiClass outerClass, @Nullable String superClassName) { Project project = outerClass.getProject(); PsiClass psiClass = JavaPsiFacade.getElementFactory(project).createClass(name); psiClass = (PsiClass)outerClass.addBefore(psiClass, outerClass.getRBrace()); PsiUtil.setModifierProp... | createClassInOuterImpl |
75,696 | PsiDirectory (@NotNull String packageName, @NotNull PsiDirectory rootDir) { if (packageName.isEmpty()) { return rootDir; } PsiDirectory directory = rootDir; String[] shortNames = packageName.split("\\."); for (String lastName : shortNames) { PsiDirectory subdirectory = directory.findSubdirectory(lastName); if (subdirec... | getOrCreatePackageDirInRoot |
75,697 | PsiClass (@NotNull String classFQN, @NotNull CreateClassKind classKind, @NotNull PsiDirectory rootDir, @NotNull PsiElement contextElement, @Nullable String superClassName) { String packageName = StringUtil.getPackageName(classFQN); int lastDot = classFQN.lastIndexOf('.'); String className = lastDot >= 0 ? classFQN.subs... | createClassInRoot |
75,698 | PsiDirectory[] (Module module) { List<VirtualFile> roots = new ArrayList<>(); JavaProjectRootsUtil.collectSuitableDestinationSourceRoots(module, roots); PsiManager psiManager = PsiManager.getInstance(module.getProject()); return roots.stream() .map(psiManager::findDirectory) .filter(Objects::nonNull) .sorted(Comparator... | getModuleRootDirs |
75,699 | void (@Nullable PsiClass psiClass) { if (psiClass != null) { CodeInsightUtil.positionCursor(psiClass.getProject(), psiClass.getContainingFile(), psiClass); } } | positionCursor |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.