Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
77,300 | ASTNode (@NotNull ASTNode element, boolean addImports, boolean incompleteCode, boolean useFqInJavadoc, boolean useFqInCode) { IElementType elementType = element.getElementType(); if ((elementType == JavaElementType.JAVA_CODE_REFERENCE || elementType == JavaElementType.REFERENCE_EXPRESSION) && !isAnnotated(element)) { I... | process |
77,301 | ASTNode (@NotNull ASTNode element, boolean addImports, boolean incompleteCode, Project project) { final CodeStyleSettings settings = CodeStyle.getSettings(element.getPsi().getContainingFile()); JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); return process(element, addImpor... | process |
77,302 | boolean (ASTNode element) { PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement)element.getPsi(); PsiElement qualifier = ref.getQualifier(); if (qualifier instanceof PsiJavaCodeReferenceElement) { if (((PsiJavaCodeReferenceElement)qualifier).resolve() instanceof PsiPackage) { return false; } if (PsiTreeUtil.... | isAnnotated |
77,303 | void (@NotNull ASTNode element, int startOffset, int endOffset, boolean useFqInJavadoc, boolean useFqInCode) { List<ASTNode> array = new ArrayList<>(); addReferencesInRange(array, element, startOffset, endOffset); for (ASTNode ref : array) { if (ref.getPsi().isValid()) { process(ref, true, true, useFqInJavadoc, useFqIn... | processRange |
77,304 | void (@NotNull ASTNode element, int startOffset, int endOffset, Project project) { final CodeStyleSettings settings = CodeStyle.getSettings(element.getPsi().getContainingFile()); JavaCodeStyleSettings javaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); processRange(element, startOffset, endOffset, j... | processRange |
77,305 | void (List<? super ASTNode> array, ASTNode parent, int startOffset, int endOffset) { if (parent.getElementType() == JavaElementType.JAVA_CODE_REFERENCE || parent.getElementType() == JavaElementType.REFERENCE_EXPRESSION) { array.add(parent); return; } if (parent.getPsi() instanceof PsiFile) { JspFile jspFile = JspPsiUti... | addReferencesInRange |
77,306 | void (List<? super ASTNode> array, ASTNode parent, int startOffset, int endOffset) { int offset = 0; for (ASTNode child = parent.getFirstChildNode(); child != null; child = child.getTreeNext()) { int length = child.getTextLength(); if (startOffset <= offset + length && offset <= endOffset) { IElementType type = child.g... | addReferencesInRangeForComposite |
77,307 | ASTNode (@NotNull CompositeElement reference, @NotNull PsiClass refClass, boolean addImports) { @NotNull final PsiJavaCodeReferenceElement psiReference = (PsiJavaCodeReferenceElement)reference.getPsi(); final PsiQualifiedReferenceElement reference1 = getClassReferenceToShorten(refClass, addImports, psiReference); if (r... | makeShortReference |
77,308 | PsiQualifiedReferenceElement (@NotNull final PsiClass refClass, final boolean addImports, @NotNull final PsiQualifiedReferenceElement reference) { PsiClass parentClass = refClass.getContainingClass(); if (parentClass != null) { JavaPsiFacade facade = JavaPsiFacade.getInstance(parentClass.getProject()); final PsiResolve... | getClassReferenceToShorten |
77,309 | boolean (@NotNull PsiElement psiReference, @NotNull PsiClass refClass) { return isSafeToShortenReference(refClass.getName(), psiReference, refClass); } | isSafeToShortenReference |
77,310 | boolean (final String referenceText, final PsiElement psiReference, final PsiClass refClass) { final PsiManager manager = refClass.getManager(); final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); final PsiResolveHelper helper = facade.getResolveHelper(); if (manager.areElementsEquivalent(refC... | isSafeToShortenReference |
77,311 | ASTNode (PsiQualifiedReferenceElement reference) { ASTNode node = reference.getNode(); assert node != null; deQualifyImpl(reference); return node; } | replaceReferenceWithShort |
77,312 | void (PsiQualifiedReferenceElement reference) { PsiElement qualifier = reference.getQualifier(); if (qualifier != null) { ASTNode qNode = qualifier.getNode(); if (qNode == null) return; ASTNode firstChildNode = qNode.getFirstChildNode(); boolean markToReformatBefore = firstChildNode instanceof TreeElement && CodeEditUt... | deQualifyImpl |
77,313 | ASTNode (ASTNode reference, PsiClass refClass) { ((SourceJavaCodeReference)reference).fullyQualify(refClass); return reference; } | replaceReferenceWithFQ |
77,314 | void (PsiStatement statement, PsiStatement blockCandidate, int options) { if (blockCandidate instanceof PsiBlockStatement || blockCandidate == null) return; if (options == CommonCodeStyleSettings.FORCE_BRACES_ALWAYS || (options == CommonCodeStyleSettings.FORCE_BRACES_IF_MULTILINE && PostFormatProcessorHelper.isMultilin... | processStatement |
77,315 | void (@NotNull PsiStatement statement, PsiStatement blockCandidate) { if (!statement.isValid()) { LOG.assertTrue(false); } if (!checkRangeContainsElement(blockCandidate)) return; if (blockCandidate instanceof PsiEmptyStatement) return; final PsiManager manager = statement.getManager(); LOG.assertTrue(manager != null); ... | replaceWithBlock |
77,316 | void (final int oldTextLength, final int newTextLength) { myPostProcessor.updateResultRange(oldTextLength, newTextLength); } | updateResultRange |
77,317 | boolean (final PsiElement element) { return myPostProcessor.isElementPartlyInRange(element); } | checkElementContainsRange |
77,318 | boolean (final PsiElement element) { return myPostProcessor.isElementFullyInRange(element); } | checkRangeContainsElement |
77,319 | PsiElement (PsiElement formatted) { LOG.assertTrue(formatted.isValid()); formatted.accept(this); return formatted; } | process |
77,320 | TextRange (final PsiFile source, final TextRange rangeToReformat) { myPostProcessor.setResultTextRange(rangeToReformat); source.accept(this); return myPostProcessor.getResultTextRange(); } | processText |
77,321 | int (@NotNull PsiFile file, @NotNull final ASTNode element, final boolean includeNonSpace, final int recursionLevel) { if (recursionLevel > TOO_BIG_WALK_THRESHOLD) return 0; if (element.getTreePrev() != null) { ASTNode prev = element.getTreePrev(); while (prev instanceof CompositeElement && !TreeUtil.isStrongWhitespace... | getIndentInner |
77,322 | int (ASTNode root, ASTNode child) { if (child == root) return 0; ASTNode parent = child.getTreeParent(); int offset = 0; for (ASTNode child1 = parent.getFirstChildNode(); child1 != child; child1 = child1.getTreeNext()) { offset += child1.getTextLength(); } return getStartOffset(root, parent) + offset; } | getStartOffset |
77,323 | ASTNode (ASTNode element, int indentShift) { if (indentShift == 0) return element; final CharTable charTableByTree = SharedImplUtil.findCharTableByTree(element); String text = element.getText(); for (int offset = 0; offset < text.length(); offset++) { char c = text.charAt(offset); if (c == '\n' || c == '\r') { int offs... | shiftIndentInside |
77,324 | boolean (final ASTNode leaf) { return (isComment(leaf) && !checkJspTexts(leaf)) || leaf.getElementType() == TokenType.WHITE_SPACE || leaf.getElementType() == XmlTokenType.XML_DATA_CHARACTERS || leaf.getElementType() instanceof JspJavaCodeType || leaf.getElementType() instanceof JspScriptletType || leaf.getElementType()... | mayShiftIndentInside |
77,325 | boolean (final ASTNode leaf) { ASTNode child = leaf.getFirstChildNode(); while(child != null){ if(child instanceof OuterLanguageElement) return true; child = child.getTreeNext(); } return false; } | checkJspTexts |
77,326 | FileType () { return myFile.getFileType(); } | getFileType |
77,327 | TextRange (@NotNull final ASTNode element, @NotNull final TextRange range) { PsiElement e = SourceTreeToPsiMap.treeElementToPsi(element); assert e != null && e.isValid(); final PsiFile file = e.getContainingFile(); final Project project = e.getProject(); if (!CodeStyle.getCustomSettings(file, JavaCodeStyleSettings.clas... | process |
77,328 | TextRange (@NotNull Project project, @NotNull ASTNode element, @NotNull final TextRange markedRange) { TextRange resultTextRange = markedRange; final PsiElement elementPsi = element.getPsi(); assert elementPsi.isValid(); final PsiFile file = elementPsi.getContainingFile(); boolean shouldFormat = markedRange.contains(el... | formatCommentsInner |
77,329 | boolean (final XmlTag tag) { return PAGE_DIRECTIVE.equals(tag.getName()); } | isPageDirectiveTag |
77,330 | String (final int startOffset, final String value) { final StringBuilder result = new StringBuilder(); String offset = calcOffset(startOffset); final String[] imports = value.split(","); if (imports.length >=1) { result.append(imports[0]); for (int i = 1; i < imports.length; i++) { String anImport = imports[i]; result.... | formatImports |
77,331 | String (final int startOffset) { final StringBuffer result = new StringBuffer(); final int lineStartOffset = myDocumentModel.getLineStartOffset(myDocumentModel.getLineNumber(startOffset)); final int emptyLineEnd = CharArrayUtil.shiftForward(myDocumentModel.getDocument().getCharsSequence(), lineStartOffset, " \t"); fina... | calcOffset |
77,332 | void (final StringBuffer result, final int count) { if (myIndentOptions.USE_TAB_CHARACTER && ! myIndentOptions.SMART_TABS) { int tabsCount = count / myIndentOptions.TAB_SIZE; int spaceCount = count - tabsCount * myIndentOptions.TAB_SIZE; StringUtil.repeatSymbol(result, '\t', tabsCount); StringUtil.repeatSymbol(result, ... | appendSpaces |
77,333 | ASTNode (final ASTNode node) { ASTNode child = node.getFirstChildNode(); while (child != null){ if (child.getElementType() == XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN) return child; child = child.getTreeNext(); } return null; } | findValueToken |
77,334 | boolean (final XmlAttribute attribute) { return IMPORT_ATT.equals(attribute.getName()); } | isImportAttribute |
77,335 | void (final int oldTextLength, final int newTextLength) { myPostProcessor.updateResultRange(oldTextLength, newTextLength); } | updateResultRange |
77,336 | boolean (final PsiElement element) { return myPostProcessor.isElementPartlyInRange(element); } | checkElementContainsRange |
77,337 | boolean (final PsiElement element) { return myPostProcessor.isElementFullyInRange(element); } | checkRangeContainsElement |
77,338 | PsiElement (PsiElement formatted) { LOG.assertTrue(formatted.isValid()); formatted.accept(this); return formatted; } | process |
77,339 | TextRange (final PsiFile source, final TextRange rangeToReformat) { myPostProcessor.setResultTextRange(rangeToReformat); source.accept(this); return myPostProcessor.getResultTextRange(); } | processText |
77,340 | PsiElement (@NotNull PsiElement element) { final ReferenceAdjuster adjuster = ReferenceAdjuster.Extension.getReferenceAdjuster(element.getLanguage()); if (adjuster != null) { final ASTNode reference = adjuster.process(element.getNode(), false, false, true, true); return SourceTreeToPsiMap.treeToPsiNotNull(reference); }... | qualifyClassReferences |
77,341 | PsiImportList (@NotNull PsiJavaFile file) { return new ImportHelper(JavaCodeStyleSettings.getInstance(file)).prepareOptimizeImportsResult(file); } | prepareOptimizeImportsResult |
77,342 | boolean (@NotNull PsiJavaFile file, @NotNull PsiClass psiClass, @NotNull String referenceName) { return ImportHelper.hasConflictingOnDemandImport(file, psiClass, referenceName); } | hasConflictingOnDemandImport |
77,343 | boolean (@NotNull PsiJavaFile file, @NotNull PsiClass refClass) { return new ImportHelper(JavaCodeStyleSettings.getInstance(file)).addImport(file, refClass); } | addImport |
77,344 | Collection<PsiImportStatementBase> (@NotNull final PsiJavaFile file) { final PsiImportList importList = file.getImportList(); if (importList == null) return null; final PsiImportStatementBase[] imports = importList.getAllImportStatements(); if (imports.length == 0) return null; Set<PsiImportStatementBase> allImports = ... | findRedundantImports |
77,345 | void (@NotNull PsiJavaCodeReferenceElement reference) { if (!reference.isQualified()) { final JavaResolveResult resolveResult = reference.advancedResolve(false); if (!inTheSamePackage(file, resolveResult.getElement())) { final PsiElement resolveScope = resolveResult.getCurrentFileResolveScope(); if (resolveScope instan... | visitReferenceElement |
77,346 | boolean (PsiJavaFile file, PsiElement element) { if (element instanceof PsiClass && ((PsiClass)element).getContainingClass() == null) { final PsiFile containingFile = element.getContainingFile(); return containingFile instanceof PsiClassOwner && Comparing.strEqual(file.getPackageName(), ((PsiClassOwner)containingFile).... | inTheSamePackage |
77,347 | int (@NotNull PsiImportStatementBase statement) { return new ImportHelper(JavaCodeStyleSettings.getInstance(statement.getContainingFile())).findEntryIndex(statement); } | findEntryIndex |
77,348 | SuggestedNameInfo (@NotNull final VariableKind kind, @Nullable final String propertyName, @Nullable final PsiExpression expr, @Nullable PsiType type, final boolean correctKeywords) { if (expr != null && type == null) { type = expr.getType(); } Set<String> names = new LinkedHashSet<>(); if (propertyName != null) { Strin... | suggestVariableName |
77,349 | void (String name) { if (_propertyName != null || _type != null) { JavaStatisticsManager.incVariableNameUseCount(name, kind, _propertyName, _type); } } | nameChosen |
77,350 | void (Set<String> names) { names.remove("of"); names.remove("to"); } | filterOutBadNames |
77,351 | void (@NotNull Set<? super String> names, @NotNull VariableKind variableKind, @Nullable String propertyName, @Nullable PsiType type) { String[] allNames = JavaStatisticsManager.getAllVariableNamesUsed(variableKind, propertyName, type); int maxFrequency = 0; for (String name : allNames) { int count = JavaStatisticsManag... | addNamesFromStatistics |
77,352 | Collection<String> (@NotNull PsiType type) { String fromTypeMap = suggestNameFromTypeMap(type, VariableKind.PARAMETER, type.getCanonicalText()); if (fromTypeMap != null) { return Collections.singletonList(fromTypeMap); } return suggestNamesFromTypeName(type, VariableKind.PARAMETER, getTypeNameWithoutIndex(type.getDeepC... | doSuggestParameterNamesByTypeWithoutIndex |
77,353 | Collection<String> (@NotNull PsiType type, @NotNull final VariableKind variableKind) { String fromTypeMap = suggestNameFromTypeMap(type, variableKind, getLongTypeName(type)); if (fromTypeMap != null && type instanceof PsiPrimitiveType) { return Collections.singletonList(fromTypeMap); } final Collection<String> suggesti... | doSuggestNamesByType |
77,354 | String (@NotNull PsiType type, @NotNull VariableKind variableKind, @Nullable String longTypeName) { if (longTypeName != null) { if (type.equals(PsiTypes.nullType())) { longTypeName = CommonClassNames.JAVA_LANG_OBJECT; } String name = nameByType(longTypeName, variableKind); if (name != null && isIdentifier(name)) { retu... | suggestNameFromTypeMap |
77,355 | String (@NotNull String longTypeName, @NotNull VariableKind kind) { if (kind == VariableKind.PARAMETER) { return switch (longTypeName) { case "int", "boolean", "byte", "char", "long" -> longTypeName.substring(0, 1); case "double", "float" -> "v"; case "short" -> "i"; case CommonClassNames.JAVA_LANG_OBJECT -> "o"; case ... | nameByType |
77,356 | void (@NotNull VariableKind variableKind, @NotNull PsiClassType classType, @NotNull Collection<? super String> suggestions) { final PsiType optionalContent = extractOptionalContent(classType); if (optionalContent == null) return; final Collection<String> contentSuggestions = doSuggestNamesByType(optionalContent, variab... | suggestFromOptionalContent |
77,357 | List<String> (@NotNull PsiType type, @NotNull VariableKind variableKind, @Nullable String typeName) { if (typeName == null) return Collections.emptyList(); typeName = normalizeTypeName(typeName); String result = type instanceof PsiArrayType ? StringUtil.pluralize(typeName) : typeName; if (variableKind == VariableKind.P... | suggestNamesFromTypeName |
77,358 | PsiType (@NotNull PsiClassType classType) { final PsiClass resolved = classType.resolve(); if (resolved != null && CommonClassNames.JAVA_UTIL_OPTIONAL.equals(resolved.getQualifiedName())) { if (classType.getParameterCount() == 1) { return classType.getParameters()[0]; } } return null; } | extractOptionalContent |
77,359 | void (@NotNull PsiClassType type, @NotNull Collection<? super String> suggestions) { final PsiClass resolved = type.resolve(); if (resolved == null || resolved.getContainingClass() == null) return; InheritanceUtil.processSupers(resolved, false, superClass -> { if (PsiTreeUtil.isAncestor(superClass, resolved, true)) { s... | suggestNamesFromHierarchy |
77,360 | void (@NotNull PsiClassType type, @NotNull Collection<? super String> suggestions) { PsiType[] parameters = type.getParameters(); if (parameters.length == 0) return; StringBuilder fullNameBuilder = new StringBuilder(); for (PsiType parameter : parameters) { if (parameter instanceof PsiClassType) { final String typeName... | suggestNamesFromGenericParameters |
77,361 | void (@NotNull PsiClassType type, @NotNull Collection<? super String> suggestions) { PsiType componentType = PsiUtil.extractIterableTypeParameter(type, false); if (componentType == null || componentType.equals(type)) { return; } String typeName = normalizeTypeName(getTypeName(componentType)); if (typeName != null) { su... | suggestNamesForCollectionInheritors |
77,362 | String (@Nullable String typeName) { if (typeName == null) { return null; } if (typeName.endsWith(IMPL_SUFFIX) && typeName.length() > IMPL_SUFFIX.length()) { return typeName.substring(0, typeName.length() - IMPL_SUFFIX.length()); } return typeName; } | normalizeTypeName |
77,363 | String (@NotNull PsiType type) { type = type.getDeepComponentType(); return type instanceof PsiClassType ? ((PsiClassType)type).getClassName() : type instanceof PsiPrimitiveType ? type.getPresentableText() : null; } | getTypeNameWithoutIndex |
77,364 | String (@NotNull PsiType type) { type = type.getDeepComponentType(); if (type instanceof PsiClassType classType) { final String className = classType.getClassName(); if (className != null) return className; final PsiClass aClass = classType.resolve(); return aClass instanceof PsiAnonymousClass ? ((PsiAnonymousClass)aCl... | getTypeName |
77,365 | String (@NotNull PsiType type) { if (type instanceof PsiClassType) { PsiClass aClass = ((PsiClassType)type).resolve(); if (aClass == null) { return null; } else if (aClass instanceof PsiAnonymousClass) { PsiClass baseClass = ((PsiAnonymousClass)aClass).getBaseClassType().resolve(); return baseClass != null ? baseClass.... | getLongTypeName |
77,366 | NamesByExprInfo (@NotNull PsiExpression expr, @Nullable VariableKind variableKind) { List<String> fromLiteral = ExpressionUtils.nonStructuralChildren(expr) .map(e -> e instanceof PsiLiteralExpression literal && literal.getValue() instanceof String str ? str : null) .filter(Objects::nonNull) .flatMap(literal -> LiteralN... | suggestVariableNameByExpression |
77,367 | String (@NotNull PsiExpression expr, @Nullable VariableKind kind) { if (kind == null || kind == VariableKind.LOCAL_VARIABLE) { return null; } PsiExpression expression = PsiUtil.skipParenthesizedExprDown(expr); if (expression instanceof PsiReferenceExpression referenceExpression && referenceExpression.resolve() instance... | suggestVariableNameFromConstant |
77,368 | String (@NotNull PsiExpression expr) { String text = findLiteralText(expr); if (text == null) return null; return expr.getType() instanceof PsiArrayType ? StringUtil.pluralize(text) : text; } | suggestVariableNameFromLiterals |
77,369 | boolean (String text) { if (!StringUtil.isQuotedString(text)) return false; String stringPresentation = StringUtil.unquoteString(text); String[] words = stringPresentation.split(" "); if (words.length > 5) return false; return ContainerUtil.and(words, StringUtil::isJavaIdentifier); } | isNameSupplier |
77,370 | String (@NotNull PsiExpression expr) { final PsiLiteralExpression[] literals = SyntaxTraverser.psiTraverser(expr) .filter(PsiLiteralExpression.class) .filter(lit -> isNameSupplier(lit.getText())) .filter(lit -> { final PsiElement exprList = lit.getParent(); if (!(exprList instanceof PsiExpressionList)) return false; fi... | findLiteralText |
77,371 | NamesByExprInfo (@NotNull PsiExpression expr, @Nullable VariableKind variableKind, boolean useAllMethodNames) { if (expr instanceof PsiMethodCallExpression) { PsiReferenceExpression methodExpr = ((PsiMethodCallExpression)expr).getMethodExpression(); String methodName = methodExpr.getReferenceName(); if (methodName != n... | suggestVariableNameByExpressionOnly |
77,372 | boolean (@NotNull PsiMethodCallExpression expr) { PsiMethod method = expr.resolveMethod(); if (method == null) return false; return isJavaUtilMethod(method) || !MethodDeepestSuperSearcher.processDeepestSuperMethods(method, method1 -> !isJavaUtilMethod(method1)); } | isJavaUtilMethodCall |
77,373 | boolean (@NotNull PsiMethod method) { String name = PsiUtil.getMemberQualifiedName(method); return name != null && name.startsWith("java.util."); } | isJavaUtilMethod |
77,374 | String (@NotNull PsiReferenceExpression expression) { return getPropertyName(expression, false); } | getPropertyName |
77,375 | String (@NotNull PsiReferenceExpression expression, boolean skipUnresolved) { String propertyName = expression.getReferenceName(); if (propertyName == null) return null; PsiElement refElement = expression.resolve(); if (refElement instanceof PsiVariable) { VariableKind refVariableKind = getVariableKind((PsiVariable)ref... | getPropertyName |
77,376 | String (String @NotNull [] names) { return String.join("_", names); } | constantValueToConstantName |
77,377 | NamesByExprInfo (@NotNull PsiExpression expr, @Nullable VariableKind variableKind) { if (expr.getParent() instanceof PsiExpressionList list) { PsiElement listParent = list.getParent(); PsiSubstitutor subst = PsiSubstitutor.EMPTY; PsiMethod method = null; if (listParent instanceof PsiMethodCallExpression call) { final J... | suggestVariableNameByExpressionPlace |
77,378 | String (@NotNull String name, @NotNull VariableKind variableKind) { if (variableKind == VariableKind.STATIC_FINAL_FIELD || variableKind == VariableKind.STATIC_FIELD && name.contains("_")) { StringBuilder buffer = new StringBuilder(); for (int i = 0; i < name.length(); i++) { char c = name.charAt(i); if (c != '_') { if ... | variableNameToPropertyName |
77,379 | String (@NotNull String name, @NotNull VariableKind variableKind) { String prefix = getPrefixByVariableKind(variableKind); String suffix = getSuffixByVariableKind(variableKind); boolean doDecapitalize = false; int pLength = prefix.length(); if (pLength > 0 && name.startsWith(prefix) && name.length() > pLength && // che... | variableNameToPropertyNameInner |
77,380 | String (@NotNull String propertyName, @NotNull VariableKind variableKind) { if (variableKind == VariableKind.STATIC_FINAL_FIELD) { String[] words = NameUtilCore.nameToWords(propertyName); return StringUtil.join(words, StringUtil::toUpperCase, "_"); } String prefix = getPrefixByVariableKind(variableKind); String name = ... | propertyNameToVariableName |
77,381 | Collection<String> (@NotNull Iterable<String> names, @NotNull VariableKind kind, boolean correctKeywords) { final Collection<String> suggestions = new LinkedHashSet<>(); for (String name : names) { suggestions.addAll(getSuggestionsByName(name, kind, correctKeywords)); } return suggestions; } | getSuggestionsByNames |
77,382 | Collection<String> (@NotNull String name, @NotNull VariableKind variableKind, boolean correctKeywords) { if (!StringUtil.isJavaIdentifier(name)) return List.of(); boolean upperCaseStyle = variableKind == VariableKind.STATIC_FINAL_FIELD; boolean preferLongerNames = getJavaSettings().PREFER_LONGER_NAMES; String prefix = ... | getSuggestionsByName |
77,383 | String (@NotNull String name, String prefix, String suffix, boolean upperCaseStyle) { String[] words = NameUtil.splitNameIntoWords(name); for (int i = 1; i < words.length; i++) { for (String preposition : ourPrepositions) { if (preposition.equalsIgnoreCase(words[i])) { String mainWord = words[i - 1]; if (upperCaseStyle... | getWordByPreposition |
77,384 | String (@NotNull String baseName, PsiElement place, boolean lookForward) { Predicate<PsiVariable> canBeReused = v -> place instanceof PsiParameter && !PsiTreeUtil.isAncestor(((PsiParameter)place).getDeclarationScope(), v, false); return suggestUniqueVariableName(baseName, place, lookForward, false, canBeReused); } | suggestUniqueVariableName |
77,385 | String (@NotNull String baseName, PsiElement place, Predicate<? super PsiVariable> canBeReused) { return suggestUniqueVariableName(baseName, place, true, false, canBeReused); } | suggestUniqueVariableName |
77,386 | SuggestedNameInfo (@NotNull final SuggestedNameInfo baseNameInfo, PsiElement place, boolean ignorePlaceName, boolean lookForward) { final String[] names = baseNameInfo.names; final LinkedHashSet<String> uniqueNames = new LinkedHashSet<>(names.length); for (String name : names) { if (ignorePlaceName && place instanceof ... | suggestUniqueVariableName |
77,387 | void (String name) { baseNameInfo.nameChosen(name); } | nameChosen |
77,388 | String (@NotNull String baseName, PsiElement place, boolean lookForward, boolean allowShadowing, Predicate<? super PsiVariable> canBeReused) { PsiElement scope = PsiTreeUtil.getNonStrictParentOfType(place, PsiStatement.class, PsiCodeBlock.class, PsiMethod.class); for (int index = 0; ; index++) { String name = index > 0... | suggestUniqueVariableName |
77,389 | boolean (@Nullable PsiElement place, @NotNull String name, boolean allowShadowing) { if (place == null) { return false; } PsiResolveHelper helper = JavaPsiFacade.getInstance(place.getProject()).getResolveHelper(); PsiVariable existingVariable = helper.resolveAccessibleReferencedVariable(name, place); if (existingVariab... | hasConflictingVariable |
77,390 | boolean (@Nullable PsiElement scope, @NotNull final String name, @NotNull Predicate<? super PsiVariable> canBeReused) { PsiElement run = scope; class Visitor extends JavaRecursiveElementWalkingVisitor { boolean hasConflict = false; @Override public void visitClass(final @NotNull PsiClass aClass) {} @Override public voi... | hasConflictingVariableAfterwards |
77,391 | void (final @NotNull PsiClass aClass) {} | visitClass |
77,392 | void (@NotNull PsiVariable variable) { if (name.equals(variable.getName()) && !canBeReused.test(variable)) { hasConflict = true; stopWalking(); } super.visitVariable(variable); } | visitVariable |
77,393 | void (String @NotNull [] names, @NotNull final VariableKind variableKind, @Nullable final String propertyName, @Nullable final PsiType type) { if (names.length <= 1) { return; } if (LOG.isDebugEnabled()) { LOG.debug("sorting names:" + variableKind); if (propertyName != null) { LOG.debug("propertyName:" + propertyName);... | sortVariableNameSuggestions |
77,394 | String (@NotNull VariableKind variableKind) { return switch (variableKind) { case FIELD -> getJavaSettings().FIELD_NAME_PREFIX; case STATIC_FIELD -> getJavaSettings().STATIC_FIELD_NAME_PREFIX; case PARAMETER -> getJavaSettings().PARAMETER_NAME_PREFIX; case LOCAL_VARIABLE -> getJavaSettings().LOCAL_VARIABLE_NAME_PREFIX;... | getPrefixByVariableKind |
77,395 | String (@NotNull VariableKind variableKind) { return switch (variableKind) { case FIELD -> getJavaSettings().FIELD_NAME_SUFFIX; case STATIC_FIELD -> getJavaSettings().STATIC_FIELD_NAME_SUFFIX; case PARAMETER -> getJavaSettings().PARAMETER_NAME_SUFFIX; case LOCAL_VARIABLE -> getJavaSettings().LOCAL_VARIABLE_NAME_SUFFIX;... | getSuffixByVariableKind |
77,396 | Collection<String> (@NotNull PsiExpression expression) { return suggestVariableNameByExpression(expression, null).names; } | suggestSemanticNames |
77,397 | Collection<String> (@NotNull PsiExpression expression, @NotNull VariableKind kind) { return suggestVariableNameByExpression(expression, kind).names; } | suggestSemanticNames |
77,398 | Collection<String> (@Nullable PsiType type, @NotNull VariableKind kind) { return type == null ? Collections.emptyList() : doSuggestNamesByType(type, kind); } | suggestSemanticNamesByType |
77,399 | SuggestedNameInfo (@NotNull Collection<String> semanticNames, @NotNull VariableKind kind, @Nullable PsiType type) { final Iterable<String> allSemanticNames = ContainerUtil.concat( semanticNames, suggestSemanticNamesByType(type, kind) ); final Set<String> suggestions = new LinkedHashSet<>(getSuggestionsByNames(allSemant... | suggestNames |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.