Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
30,600
boolean (GrStatement statement, boolean testForSuper, boolean testForThis) { if (!(statement instanceof GrConstructorInvocation expr)) return false; return (testForSuper && expr.isSuperCall()) || (testForThis && expr.isThisCall()); }
isSuperOrThisCall
30,601
boolean (PsiElement element) { ArrayList<GrBreakStatement> vector = new ArrayList<>(); addBreakStatements(element, vector); return !vector.isEmpty(); }
hasWrongBreakStatements
30,602
void (PsiElement element, ArrayList<? super GrBreakStatement> vector) { if (element instanceof GrBreakStatement) { vector.add(((GrBreakStatement) element)); } else if (!(element instanceof GrLoopStatement || element instanceof GrSwitchStatement || element instanceof GrClosableBlock)) { for (PsiElement psiElement : element.getChildren()) { addBreakStatements(psiElement, vector); } } }
addBreakStatements
30,603
boolean (PsiElement element) { ArrayList<GrContinueStatement> vector = new ArrayList<>(); addContinueStatements(element, vector); return !vector.isEmpty(); }
hasWrongContinueStatements
30,604
void (PsiElement element, ArrayList<? super GrContinueStatement> vector) { if (element instanceof GrContinueStatement) { vector.add(((GrContinueStatement) element)); } else if (!(element instanceof GrLoopStatement || element instanceof GrClosableBlock)) { for (PsiElement psiElement : element.getChildren()) { addContinueStatements(psiElement, vector); } } }
addContinueStatements
30,605
GrCall (@Nullable PsiElement ref) { if (ref == null) return null; if (ref instanceof GrEnumConstant) return (GrEnumConstant)ref; if (ref instanceof GrConstructorInvocation) return (GrCall)ref; PsiElement parent = ref.getParent(); if (parent instanceof GrCall) { return (GrCall)parent; } else if (parent instanceof GrAnonymousClassDefinition) { return (GrCall)parent.getParent(); } else { return null; } }
getCallExpressionByMethodReference
30,606
boolean (PsiElement ref) { return (ref instanceof GrEnumConstant) || (ref.getParent() instanceof GrCall) || (ref instanceof GrConstructorInvocation); }
isMethodUsage
30,607
String (GrExpression expr, final GroovyPsiElement context, boolean declareFinal) { expr = addBlockIntoParent(expr); final GrVariableDeclarationOwner block = PsiTreeUtil.getParentOfType(expr, GrVariableDeclarationOwner.class); LOG.assertTrue(block != null); final PsiElement anchorStatement = PsiTreeUtil.findPrevParent(block, expr); LOG.assertTrue(anchorStatement instanceof GrStatement); Project project = expr.getProject(); String[] suggestedNames =GroovyNameSuggestionUtil.suggestVariableNames(expr, new NameValidator() { @Override public String validateName(String name, boolean increaseNumber) { return name; } @Override public Project getProject() { return context.getProject(); } }); /* JavaCodeStyleManager.getInstance(project).suggestVariableName(VariableKind.LOCAL_VARIABLE, null, expr, null).names;*/ final String prefix = suggestedNames[0]; final String id = JavaCodeStyleManager.getInstance(project).suggestUniqueVariableName(prefix, context, true); GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(expr.getProject()); String[] modifiers; if (declareFinal) { modifiers = finalModifiers; } else { modifiers = ArrayUtilRt.EMPTY_STRING_ARRAY; } GrVariableDeclaration decl = factory.createVariableDeclaration(modifiers, (GrExpression)org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil .skipParentheses(expr, false), expr.getType(), id); final GrStatement statement = ((GrStatementOwner)anchorStatement.getParent()).addStatementBefore(decl, (GrStatement)anchorStatement); JavaCodeStyleManager.getInstance(statement.getProject()).shortenClassReferences(statement); return id; }
createTempVar
30,608
String (String name, boolean increaseNumber) { return name; }
validateName
30,609
Project () { return context.getProject(); }
getProject
30,610
int (GrExpression expression) { return verifySafeCopyExpressionSubElement(expression); }
verifySafeCopyExpression
30,611
int (PsiElement element) { int result = RefactoringUtil.EXPR_COPY_SAFE; if (element == null) return result; if (element instanceof GrNamedElement) { return RefactoringUtil.EXPR_COPY_SAFE; } if (element instanceof GrMethodCallExpression) { result = RefactoringUtil.EXPR_COPY_UNSAFE; } if (element instanceof GrNewExpression) { return RefactoringUtil.EXPR_COPY_PROHIBITED; } if (element instanceof GrAssignmentExpression) { return RefactoringUtil.EXPR_COPY_PROHIBITED; } if (element instanceof GrClosableBlock) { return RefactoringUtil.EXPR_COPY_PROHIBITED; } if (isPlusPlusOrMinusMinus(element)) { return RefactoringUtil.EXPR_COPY_PROHIBITED; } PsiElement[] children = element.getChildren(); for (PsiElement child : children) { int childResult = verifySafeCopyExpressionSubElement(child); result = Math.max(result, childResult); } return result; }
verifySafeCopyExpressionSubElement
30,612
boolean (String newName, Project project) { if (newName.startsWith("'''") || newName.startsWith("\"\"\"")) { if (newName.length() < 6 || !newName.endsWith("'''")) { return false; } } else if (StringUtil.startsWithChar(newName, '\'') || StringUtil.startsWithChar(newName, '"')) { if (newName.length() < 2 || !newName.endsWith("'")) { return false; } } if (KEYWORDS.contains(newName)) { return false; } try { GroovyPsiElementFactory.getInstance(project).createReferenceNameFromText(newName); } catch (IncorrectOperationException e) { return false; } return true; }
isCorrectReferenceName
30,613
GrExpression (PsiSubstitutor substitutor, List<? extends PsiElement> arguments, @Nullable PsiType type, final Project project) { StringBuilder argText = new StringBuilder(); argText.append("["); for (PsiElement argument : arguments) { argText.append(argument.getText()).append(", "); } if (!arguments.isEmpty()) { argText.delete(argText.length() - 2, argText.length()); } argText.append("]"); if (type instanceof PsiArrayType) { type = substitutor.substitute(type); String typeText = type.getCanonicalText(); if (type instanceof PsiEllipsisType) { typeText = typeText.replace("...", "[]"); } argText.append(" as ").append(typeText); } return GroovyPsiElementFactory.getInstance(project).createExpressionFromText(argText.toString()); }
generateArgFromMultiArg
30,614
boolean (@NotNull GroovyPsiElement statement) { final Ref<Boolean> hasSideEffect = new Ref<>(false); statement.accept(new GroovyRecursiveElementVisitor() { @Override public void visitMethodCallExpression(@NotNull GrMethodCallExpression methodCallExpression) { hasSideEffect.set(true); } @Override public void visitCallExpression(@NotNull GrCallExpression callExpression) { hasSideEffect.set(true); } @Override public void visitApplicationStatement(@NotNull GrApplicationStatement applicationStatement) { hasSideEffect.set(true); } @Override public void visitClosure(@NotNull GrClosableBlock closure) { hasSideEffect.set(true); } @Override public void visitUnaryExpression(@NotNull GrUnaryExpression expression) { hasSideEffect.set(true); } @Override public void visitElement(@NotNull GroovyPsiElement element) { if (hasSideEffect.get()) return; super.visitElement(element); } }); return hasSideEffect.get(); }
hasSideEffect
30,615
void (@NotNull GrMethodCallExpression methodCallExpression) { hasSideEffect.set(true); }
visitMethodCallExpression
30,616
void (@NotNull GrCallExpression callExpression) { hasSideEffect.set(true); }
visitCallExpression
30,617
void (@NotNull GrApplicationStatement applicationStatement) { hasSideEffect.set(true); }
visitApplicationStatement
30,618
void (@NotNull GrClosableBlock closure) { hasSideEffect.set(true); }
visitClosure
30,619
void (@NotNull GrUnaryExpression expression) { hasSideEffect.set(true); }
visitUnaryExpression
30,620
void (@NotNull GroovyPsiElement element) { if (hasSideEffect.get()) return; super.visitElement(element); }
visitElement
30,621
boolean (GrExpression expression) { PsiElement element = org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.skipParentheses(expression, false); if (!(element instanceof GrNewExpression)) return false; if (((GrNewExpression)element).getArrayCount() > 0) return false; GrCodeReferenceElement referenceElement = ((GrNewExpression)element).getReferenceElement(); if (referenceElement == null) return false; GrTypeArgumentList typeArgumentList = referenceElement.getTypeArgumentList(); return typeArgumentList != null && typeArgumentList.isDiamond(); }
isDiamondNewOperator
30,622
GrStatementOwner (GrStatement statement) { PsiElement parent = statement.getParent(); return parent instanceof GrStatementOwner ? ((GrStatementOwner) parent) : null; }
getDeclarationOwner
30,623
PsiType (@NotNull PsiParameter myParameter) { PsiType type = myParameter.getType(); return type instanceof PsiEllipsisType ? ((PsiEllipsisType)type).toArrayType() : type; }
getType
30,624
PsiType (@NotNull GrParameter parameter) { final PsiType type = getType(parameter); if (type instanceof PsiArrayType) { return type; } final PsiClassType.ClassResolveResult result = PsiUtil.resolveGenericsClassInType(type); final PsiClass psiClass = result.getElement(); if (psiClass == null) return type; final HashSet<PsiTypeParameter> usedTypeParameters = new HashSet<>(); collectTypeParameters(usedTypeParameters, parameter); for (Iterator<PsiTypeParameter> iterator = usedTypeParameters.iterator(); iterator.hasNext(); ) { PsiTypeParameter usedTypeParameter = iterator.next(); if (parameter.getDeclarationScope() != usedTypeParameter.getOwner()) { iterator.remove(); } } final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(parameter.getProject()); PsiSubstitutor subst = PsiSubstitutor.EMPTY; for (PsiTypeParameter usedTypeParameter : usedTypeParameters) { subst = subst.put(usedTypeParameter, TypeConversionUtil.typeParameterErasure(usedTypeParameter)); } PsiSubstitutor substitutor = PsiSubstitutor.EMPTY; final Map<PsiTypeParameter, PsiType> typeMap = result.getSubstitutor().getSubstitutionMap(); for (PsiTypeParameter typeParameter : typeMap.keySet()) { final PsiType psiType = typeMap.get(typeParameter); substitutor = substitutor.put(typeParameter, psiType != null ? subst.substitute(psiType) : null); } return psiClass instanceof PsiTypeParameter ? subst.substitute((PsiTypeParameter)psiClass) : elementFactory.createType(psiClass, substitutor); }
getSubstitutedType
30,625
void (final Set<? super PsiTypeParameter> used, @NotNull final GroovyPsiElement element) { element.accept(new GroovyRecursiveElementVisitor() { @Override public void visitCodeReferenceElement(@NotNull GrCodeReferenceElement reference) { super.visitCodeReferenceElement(reference); if (reference.getQualifier() == null) { final PsiElement resolved = reference.resolve(); if (resolved instanceof PsiTypeParameter typeParameter) { if (PsiTreeUtil.isAncestor(typeParameter.getOwner(), element, false)) { used.add(typeParameter); } } } } @Override public void visitExpression(@NotNull final GrExpression expression) { super.visitExpression(expression); final PsiType type = expression.getType(); if (type != null) { final TypeParameterSearcher searcher = new TypeParameterSearcher(); type.accept(searcher); for (PsiTypeParameter typeParam : searcher.myTypeParams) { if (PsiTreeUtil.isAncestor(typeParam.getOwner(), element, false)) { used.add(typeParam); } } } } static class TypeParameterSearcher extends PsiTypeVisitor<Boolean> { private final Set<PsiTypeParameter> myTypeParams = new HashSet<>(); @Override public Boolean visitType(@NotNull final PsiType type) { return false; } @Override public Boolean visitArrayType(@NotNull final PsiArrayType arrayType) { return arrayType.getComponentType().accept(this); } @Override public Boolean visitClassType(@NotNull final PsiClassType classType) { final PsiClass aClass = classType.resolve(); if (aClass instanceof PsiTypeParameter) { myTypeParams.add((PsiTypeParameter)aClass); } final PsiType[] types = classType.getParameters(); for (final PsiType psiType : types) { psiType.accept(this); } return false; } @Override public Boolean visitWildcardType(@NotNull final PsiWildcardType wildcardType) { final PsiType bound = wildcardType.getBound(); if (bound != null) { bound.accept(this); } return false; } } }); }
collectTypeParameters
30,626
void (@NotNull GrCodeReferenceElement reference) { super.visitCodeReferenceElement(reference); if (reference.getQualifier() == null) { final PsiElement resolved = reference.resolve(); if (resolved instanceof PsiTypeParameter typeParameter) { if (PsiTreeUtil.isAncestor(typeParameter.getOwner(), element, false)) { used.add(typeParameter); } } } }
visitCodeReferenceElement
30,627
void (@NotNull final GrExpression expression) { super.visitExpression(expression); final PsiType type = expression.getType(); if (type != null) { final TypeParameterSearcher searcher = new TypeParameterSearcher(); type.accept(searcher); for (PsiTypeParameter typeParam : searcher.myTypeParams) { if (PsiTreeUtil.isAncestor(typeParam.getOwner(), element, false)) { used.add(typeParam); } } } }
visitExpression
30,628
Boolean (@NotNull final PsiType type) { return false; }
visitType
30,629
Boolean (@NotNull final PsiArrayType arrayType) { return arrayType.getComponentType().accept(this); }
visitArrayType
30,630
Boolean (@NotNull final PsiClassType classType) { final PsiClass aClass = classType.resolve(); if (aClass instanceof PsiTypeParameter) { myTypeParams.add((PsiTypeParameter)aClass); } final PsiType[] types = classType.getParameters(); for (final PsiType psiType : types) { psiType.accept(this); } return false; }
visitClassType
30,631
Boolean (@NotNull final PsiWildcardType wildcardType) { final PsiType bound = wildcardType.getBound(); if (bound != null) { bound.accept(this); } return false; }
visitWildcardType
30,632
String (@NotNull PsiNamedElement element, boolean property) { final String name; if (element instanceof PsiMethod && property) { name = GroovyPropertyUtils.getPropertyName((PsiMethod)element); } else { name = element.getName(); } LOG.assertTrue(name != null, element); return name; }
getNewName
30,633
GroovyRefactoringSettings () { return this; }
getState
30,634
void (@NotNull GroovyRefactoringSettings state) { XmlSerializerUtil.copyBean(state, this); }
loadState
30,635
boolean (@NotNull PsiElement element) { return element instanceof GrTypeDefinition || element instanceof GrField || element instanceof GrMethod; }
isSafeDeleteAvailable
30,636
RefactoringActionHandler () { return new GrIntroduceVariableHandler(); }
getIntroduceVariableHandler
30,637
RefactoringActionHandler () { return new GroovyExtractMethodHandler(); }
getExtractMethodHandler
30,638
ChangeSignatureHandler () { return new GrChangeSignatureHandler(); }
getChangeSignatureHandler
30,639
boolean (@NotNull PsiElement elementToRename, PsiElement nameSuggestionContext) { //local vars & params renames GrVariableInplaceRenameHandler if (nameSuggestionContext != null && nameSuggestionContext.getContainingFile() != elementToRename.getContainingFile()) return false; if (!(elementToRename instanceof GrLabeledStatement)) { return false; } SearchScope useScope = PsiSearchHelper.getInstance(elementToRename.getProject()).getUseScope(elementToRename); if (!(useScope instanceof LocalSearchScope)) return false; PsiElement[] scopeElements = ((LocalSearchScope)useScope).getScope(); if (scopeElements.length > 1) { return false; } PsiFile containingFile = elementToRename.getContainingFile(); return PsiTreeUtil.isAncestor(containingFile, scopeElements[0], false); }
isInplaceRenameAvailable
30,640
boolean (@NotNull PsiElement element, PsiElement context) { if (context == null || context.getContainingFile() != element.getContainingFile()) return false; return true; }
isInplaceIntroduceAvailable
30,641
boolean (@NotNull PsiElement element, @Nullable PsiElement context) { if (context == null || context.getContainingFile() instanceof GroovyFile) return false; PsiElement parent = context.getParent(); //don't try to inplace rename aliased imported references if (parent instanceof GrReferenceElement) { GroovyResolveResult result = ((GrReferenceElement<?>)parent).advancedResolve(); PsiElement fileResolveContext = result.getCurrentFileResolveContext(); if (fileResolveContext instanceof GrImportStatement && ((GrImportStatement)fileResolveContext).isAliasedImport()) { return false; } } return element instanceof GrMember; }
isMemberInplaceRenameAvailable
30,642
RefactoringActionHandler () { return new GrIntroduceFieldHandler(); }
getIntroduceFieldHandler
30,643
RefactoringActionHandler () { return new GrIntroduceParameterHandler(); }
getIntroduceParameterHandler
30,644
RefactoringActionHandler () { return new GrIntroduceConstantHandler(); }
getIntroduceConstantHandler
30,645
RefactoringActionHandler () { return new JavaPullUpHandler(); }
getPullUpHandler
30,646
boolean (GrParameter variable, MultiMap<PsiElement,String> conflicts, @NotNull String varName) { GrParameterList list = PsiTreeUtil.getParentOfType(variable, GrParameterList.class); GrParameterListOwner owner = PsiTreeUtil.getParentOfType(variable, GrParameterListOwner.class); assert owner != null; for (GrParameter parameter : list.getParameters()) { if (parameter.equals(variable)) continue; validateVariableOccurrencesDownImpl(parameter, conflicts, varName); } validateVariableOccurrencesDown(owner, list, conflicts, varName); PsiElement parent = owner.getParent(); validateVariableOccurrencesUp(parent, owner, conflicts, varName, parent instanceof GroovyFile); return conflicts.isEmpty(); }
validateNewParameterName
30,647
void (PsiElement parent, PsiElement lastParent, MultiMap<PsiElement, String> conflicts, @NotNull String varName, final boolean containerIsFile) { if (!containerIsFile && (parent instanceof PsiFile) || parent == null) return; PsiElement child = parent.getFirstChild(); while (child != null && child != lastParent) { // Upper variable declarations if (child instanceof GrVariableDeclaration) { for (GrVariable variable : ((GrVariableDeclaration)child).getVariables()) { if (varName.equals(variable.getName())) { addConflict(varName, variable, conflicts); } } } child = child.getNextSibling(); } if (parent instanceof GrParameterListOwner owner) { //method or closure parameters for (GrParameter parameter : owner.getParameters()) { if (varName.equals(parameter.getName())) { addConflict(varName, parameter, conflicts); } } } else if (parent instanceof GrForStatement statement) { // For statement binding GrForClause clause = statement.getClause(); if (clause != null) { for (GrVariable variable : clause.getDeclaredVariables()) { if (varName.equals(variable.getName())) { addConflict(varName, variable, conflicts); } } } } if (parent instanceof PsiFile) return; validateVariableOccurrencesUp(parent.getParent(), parent, conflicts, varName, false); }
validateVariableOccurrencesUp
30,648
void (PsiElement parent, PsiElement startChild, MultiMap<PsiElement, String> conflicts, @NotNull String varName) { PsiElement child = parent.getLastChild(); while (child != null && child != startChild && !(child instanceof GrTypeDefinition)) { validateVariableOccurrencesDownImpl(child, conflicts, varName); child = child.getPrevSibling(); } }
validateVariableOccurrencesDown
30,649
void (final PsiElement child, final MultiMap<PsiElement, String> conflicts, final String varName) { if (child instanceof PsiNamedElement element) { if (varName.equals(element.getName())) { addConflict(varName, element, conflicts); } else { for (PsiElement psiElement : child.getChildren()) { if (!(child instanceof GrTypeDefinition)) { validateVariableOccurrencesDownImpl(psiElement, conflicts, varName); } } } } }
validateVariableOccurrencesDownImpl
30,650
void (@NlsSafe String varName, PsiNamedElement element, MultiMap<PsiElement, String> conflicts) { if (element instanceof GrParameter) { conflicts.putValue(element, GroovyRefactoringBundle.message("variable.conflicts.with.parameter.0", CommonRefactoringUtil.htmlEmphasize(varName))); } else if (element instanceof GrField) { conflicts.putValue(element, GroovyRefactoringBundle.message("variable.conflicts.with.field.0", CommonRefactoringUtil.htmlEmphasize(varName))); } else { conflicts.putValue(element, GroovyRefactoringBundle.message("variable.conflicts.with.variable.0", CommonRefactoringUtil.htmlEmphasize(varName))); } }
addConflict
30,651
String () { String name = myName; int i = 1; MultiMap<PsiElement, String> confl = new MultiMap<>(); while (!validateNewParameterName(myParameter, confl, name)) { name = myName + i; i++; confl = new MultiMap<>(); } return name; }
generateName
30,652
void (@NotNull GrVariable variable) { if (includeFields || !(variable instanceof PsiField)) { mySet.add(variable.getName()); } super.visitVariable(variable); }
visitVariable
30,653
void (@NotNull GrClosableBlock closure) { if (checkIntoInner) { super.visitClosure(closure); } }
visitClosure
30,654
void (@NotNull GrTypeDefinition typeDefinition) { if (checkIntoInner && !typeDefinition.hasModifierProperty(PsiModifier.STATIC) ) { super.visitTypeDefinition(typeDefinition); } }
visitTypeDefinition
30,655
String (String name, boolean increaseNumber) { if (!mySet.contains(name)) return name; if (increaseNumber) { int i = 1; //noinspection StatementWithEmptyBody for (; mySet.contains(name + i); i++) ; return name + i; } else { return ""; } }
validateName
30,656
Project () { return myContext.getProject(); }
getProject
30,657
String[] (GrExpression expr, NameValidator validator) { return suggestVariableNames(expr, validator, false); }
suggestVariableNames
30,658
String[] (@NotNull GrExpression expr, NameValidator validator, boolean forStaticVariable) { Set<String> possibleNames = new LinkedHashSet<>(); PsiType type = expr.getType(); generateNameByExpr(expr, possibleNames, validator, forStaticVariable); if (type != null && !PsiTypes.voidType().equals(type)) { generateVariableNameByTypeInner(type, possibleNames,validator); } possibleNames.remove(""); if (possibleNames.isEmpty()) { possibleNames.add(validator.validateName("var", true)); } return ArrayUtilRt.toStringArray(possibleNames); }
suggestVariableNames
30,659
String[] (PsiType type, NameValidator validator) { if (type == null) return ArrayUtilRt.EMPTY_STRING_ARRAY; Set<String> possibleNames = new LinkedHashSet<>(); generateVariableNameByTypeInner(type, possibleNames, validator); return ArrayUtilRt.toStringArray(possibleNames); }
suggestVariableNameByType
30,660
void (PsiType type, Set<String> possibleNames, NameValidator validator) { String unboxed = PsiTypesUtil.unboxIfPossible(type.getCanonicalText()); if (!unboxed.equals(type.getCanonicalText())) { String name = generateNameForBuiltInType(unboxed); name = validator.validateName(name, true); if (GroovyNamesUtil.isIdentifier(name)) { possibleNames.add(name); } } else if (type instanceof PsiIntersectionType intersectionType) { for (PsiType psiType : intersectionType.getConjuncts()) { generateByType(psiType, possibleNames, validator); } } else { generateByType(type, possibleNames, validator); } }
generateVariableNameByTypeInner
30,661
void (GrExpression expr, Set<String> possibleNames, NameValidator validator, boolean forStaticVariable) { if (expr instanceof GrReferenceExpression refExpr && ((GrReferenceExpression) expr).getReferenceName() != null) { if (PsiUtil.isThisReference(expr)) { possibleNames.add(validator.validateName("thisInstance", true)); } if (PsiUtil.isSuperReference(expr)) { possibleNames.add(validator.validateName("superInstance", true)); } String name = refExpr.getReferenceName(); if (name != null && StringUtil.toUpperCase(name).equals(name)) { possibleNames.add(validator.validateName(StringUtil.toLowerCase(name), true)); } else { generateCamelNames(possibleNames, validator, name); } if (expr.getText().equals(name)) { possibleNames.remove(name); } } if (expr instanceof GrMethodCallExpression) { generateNameByExpr(((GrMethodCallExpression) expr).getInvokedExpression(), possibleNames, validator, forStaticVariable); } if (expr instanceof GrLiteral) { final Object value = ((GrLiteral)expr).getValue(); if (value instanceof String) { generateNameByString(possibleNames, (String)value, validator, forStaticVariable, expr.getProject()); } } }
generateNameByExpr
30,662
void (Set<String> possibleNames, String value, NameValidator validator, boolean forStaticVariable, Project project) { if (!PsiNameHelper.getInstance(project).isIdentifier(value)) return; if (forStaticVariable) { StringBuilder buffer = new StringBuilder(value.length() + 10); char[] chars = new char[value.length()]; value.getChars(0, value.length(), chars, 0); boolean wasLow = Character.isLowerCase(chars[0]); buffer.append(Character.toUpperCase(chars[0])); for (int i = 1; i < chars.length; i++) { if (Character.isUpperCase(chars[i])) { if (wasLow) { buffer.append('_'); wasLow = false; } } else { wasLow = true; } buffer.append(Character.toUpperCase(chars[i])); } possibleNames.add(validator.validateName(buffer.toString(), true)); } else { possibleNames.add(validator.validateName(value, true)); } }
generateNameByString
30,663
void (PsiType type, Set<String> possibleNames, NameValidator validator) { String typeName = type.getPresentableText(); generateNamesForCollectionType(type, possibleNames, validator); generateNamesForArrayType(type, possibleNames, validator); generateNamesForExceptions(type, possibleNames, validator); typeName = cleanTypeName(typeName); if (typeName.equals("String")) { possibleNames.add(validator.validateName("s", true)); } if (typeName.equals("Closure")) { possibleNames.add(validator.validateName("cl", true)); } if (StringUtil.toUpperCase(typeName).equals(typeName)) { possibleNames.add(validator.validateName(GroovyNamesUtil.deleteNonLetterFromString(StringUtil.toLowerCase(typeName)), true)); } else if (!typeName.equals(StringUtil.toLowerCase(typeName))) { generateCamelNames(possibleNames, validator, typeName); possibleNames.remove(typeName); } }
generateByType
30,664
void (PsiType type, Set<String> possibleNames, NameValidator validator) { if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_LANG_ERROR)) { possibleNames.add(validator.validateName("error", true)); } else if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_LANG_EXCEPTION)) { possibleNames.add(validator.validateName("e", true)); } }
generateNamesForExceptions
30,665
void (PsiType type, Set<String> possibleNames, NameValidator validator) { int arrayDim = type.getArrayDimensions(); if (arrayDim == 0) return; PsiType deepType = type.getDeepComponentType(); String candidateName = cleanTypeName(deepType.getPresentableText()); if (deepType instanceof PsiClassType) { PsiClass clazz = ((PsiClassType) deepType).resolve(); if (clazz == null) return; candidateName = GroovyNamesUtil.fromLowerLetter(clazz.getName()); } candidateName = StringUtil.pluralize(GroovyNamesUtil.fromLowerLetter(candidateName)); generateCamelNames(possibleNames, validator, candidateName); ArrayList<String> camelizedName = GroovyNamesUtil.camelizeString(candidateName); candidateName = camelizedName.get(camelizedName.size() - 1); candidateName = "arrayOf" + fromUpperLetter(candidateName); possibleNames.add(validator.validateName(candidateName, true)); }
generateNamesForArrayType
30,666
void (PsiType type, Set<String> possibleNames, NameValidator validator) { PsiType componentType = getCollectionComponentType(type, validator.getProject()); if (!(type instanceof PsiClassType) || componentType == null) return; PsiClass clazz = ((PsiClassType) type).resolve(); if (clazz == null) return; String collectionName = clazz.getName(); assert collectionName != null; String componentName = cleanTypeName(componentType.getPresentableText()); if (componentType instanceof PsiClassType classType) { PsiClass psiClass = classType.resolve(); if (psiClass == null) return; componentName = psiClass.getName(); } assert componentName != null; String candidateName = StringUtil.pluralize(GroovyNamesUtil.fromLowerLetter(componentName)); generateCamelNames(possibleNames, validator, candidateName); ArrayList<String> camelizedName = GroovyNamesUtil.camelizeString(candidateName); candidateName = camelizedName.get(camelizedName.size() - 1); candidateName = StringUtil.toLowerCase(collectionName) + "Of" + fromUpperLetter(candidateName); possibleNames.add(validator.validateName(candidateName, true)); }
generateNamesForCollectionType
30,667
String (@NotNull String typeName) { if (typeName.contains(".")) { typeName = typeName.substring(typeName.lastIndexOf(".") + 1); } if (typeName.contains("<")) { typeName = typeName.substring(0, typeName.indexOf("<")); } return typeName; }
cleanTypeName
30,668
void (Set<String> possibleNames, NameValidator validator, String typeName) { ArrayList<String> camelTokens = GroovyNamesUtil.camelizeString(typeName); Collections.reverse(camelTokens); if (!camelTokens.isEmpty()) { String possibleName = ""; for (String camelToken : camelTokens) { possibleName = camelToken + fromUpperLetter(possibleName); String candidate = validator.validateName(possibleName, true); // todo generify if (candidate.equals("class")) { candidate = validator.validateName("clazz", true); } if (!possibleNames.contains(candidate) && GroovyNamesUtil.isIdentifier(candidate)) { possibleNames.add(candidate); } } } }
generateCamelNames
30,669
String (String unboxed) { return StringUtil.toLowerCase(unboxed).substring(0, 1); }
generateNameForBuiltInType
30,670
String (String str) { if (str.isEmpty()) return ""; if (str.length() == 1) return StringUtil.toUpperCase(str); return StringUtil.toUpperCase(str.substring(0, 1)) + str.substring(1); }
fromUpperLetter
30,671
PsiType (PsiType type, Project project) { if (!(type instanceof PsiClassType classType)) return null; PsiClassType.ClassResolveResult result = classType.resolveGenerics(); PsiClass clazz = result.getElement(); if (clazz == null) return null; JavaPsiFacade facade = JavaPsiFacade.getInstance(project); @SuppressWarnings({"ConstantConditions"}) PsiClass collectionClass = facade.findClass("java.util.Collection", type.getResolveScope()); if (collectionClass == null || collectionClass.getTypeParameters().length != 1) return null; PsiSubstitutor substitutor = TypeConversionUtil.getClassSubstitutor(collectionClass, clazz, result.getSubstitutor()); if (substitutor == null) return null; PsiType componentType = substitutor.substitute(collectionClass.getTypeParameters()[0]); return componentType instanceof PsiIntersectionType ? null : componentType; }
getCollectionComponentType
30,672
void (@NotNull GrReferenceExpression referenceExpression) { super.visitReferenceExpression(referenceExpression); if (PsiUtil.isSuperReference(referenceExpression)) { myContainsSupers = true; } }
visitReferenceExpression
30,673
boolean () { return myContainsSupers; }
containsSupers
30,674
DependentMembersCollectorBase (Object clazz, Object superClass) { return new GrDependantMembersCollector((PsiClass)clazz, (PsiClass)superClass); }
createDependentMembersCollector
30,675
boolean (MemberInfoBase member) { return member instanceof GrMemberInfo; }
isProperMember
30,676
Object (GrMemberInfo memberInfo) { if (!(memberInfo.getMember() instanceof PsiMethod method)) return null; if (memberInfo.isStatic()) return null; if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { final Boolean fixedAbstract = myMemberInfoModel.isFixedAbstract(memberInfo); if (fixedAbstract != null) return fixedAbstract; } if (!myMemberInfoModel.isAbstractEnabled(memberInfo)) { return myMemberInfoModel.isAbstractWhenDisabled(memberInfo); } else { return memberInfo.isToAbstract(); } }
getAbstractColumnValue
30,677
boolean (int rowIndex) { GrMemberInfo info = myMemberInfos.get(rowIndex); if (!(info.getMember() instanceof PsiMethod method)) return false; if (info.isStatic()) return false; if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { if (myMemberInfoModel.isFixedAbstract(info) != null) { return false; } } return info.isChecked() && myMemberInfoModel.isAbstractEnabled(info); }
isAbstractColumnEditable
30,678
void (GrMemberInfo memberInfo, RowIcon icon) { PsiMember member = memberInfo.getMember(); PsiModifierList modifiers = member != null ? member.getModifierList() : null; if (modifiers != null) { VisibilityIcons.setVisibilityIcon(modifiers, icon); } else { icon.setIcon(IconUtil.getEmptyIcon(true), VISIBILITY_ICON_POSITION); } }
setVisibilityIcon
30,679
Icon (GrMemberInfo memberInfo) { PsiMember member = memberInfo.getMember(); Icon overrideIcon = EMPTY_OVERRIDE_ICON; if (member instanceof PsiMethod) { if (Boolean.TRUE.equals(memberInfo.getOverrides())) { overrideIcon = AllIcons.General.OverridingMethod; } else if (Boolean.FALSE.equals(memberInfo.getOverrides())) { overrideIcon = AllIcons.General.ImplementingMethod; } else { overrideIcon = EMPTY_OVERRIDE_ICON; } } return overrideIcon; }
getOverrideIcon
30,680
GrReferenceList () { return mySourceReferenceList; }
getSourceReferenceList
30,681
List<GrMemberInfo> (GrTypeDefinition subclass, Filter<GrMember> filter, boolean extractInterfacesDeep) { List<GrMemberInfo> members = new ArrayList<>(); extractClassMembers(subclass, members, filter, extractInterfacesDeep); return members; }
extractClassMembers
30,682
void (PsiClass subclass, List<GrMemberInfo> result, Filter<GrMember> filter, final boolean extractInterfacesDeep) { if (!(subclass instanceof GrTypeDefinition)) return; if (extractInterfacesDeep) { extractSuperInterfaces(subclass, filter, result, new HashSet<>()); } else { PsiClass[] interfaces = subclass.getInterfaces(); GrReferenceList sourceRefList = subclass.isInterface() ? ((GrTypeDefinition)subclass).getExtendsClause() : ((GrTypeDefinition)subclass).getImplementsClause(); for (PsiClass anInterface : interfaces) { if (anInterface instanceof GrTypeDefinition && filter.includeMember((GrMember)anInterface)) { result.add(new GrMemberInfo((GrMember)anInterface, true, sourceRefList)); } } } PsiClass[] innerClasses = subclass.getInnerClasses(); for (PsiClass innerClass : innerClasses) { if (innerClass instanceof GrTypeDefinition && filter.includeMember((GrMember)innerClass)) { result.add(new GrMemberInfo((GrMember)innerClass)); } } GrMethod[] methods = ((GrTypeDefinition)subclass).getCodeMethods(); for (GrMethod method : methods) { if (!method.isConstructor() && filter.includeMember(method)) { result.add(new GrMemberInfo(method)); } } GrField[] fields = ((GrTypeDefinition)subclass).getCodeFields(); for (final GrField field : fields) { if (filter.includeMember(field)) { result.add(new GrMemberInfo(field)); } } }
extractClassMembers
30,683
void (final PsiClass subclass, final Filter<GrMember> filter, final List<GrMemberInfo> result, Set<PsiClass> processed) { if (!processed.contains(subclass)) { processed.add(subclass); if (subclass instanceof GrTypeDefinition) { extractSuperInterfacesFromReferenceList(((GrTypeDefinition)subclass).getExtendsClause(), filter, result, processed); extractSuperInterfacesFromReferenceList(((GrTypeDefinition)subclass).getImplementsClause(), filter, result, processed); } } }
extractSuperInterfaces
30,684
void (final GrReferenceList referenceList, final Filter<GrMember> filter, final List<GrMemberInfo> result, final Set<PsiClass> processed) { if (referenceList != null) { final PsiClassType[] extendsListTypes = referenceList.getReferencedTypes(); for (PsiClassType extendsListType : extendsListTypes) { final PsiClass aSuper = extendsListType.resolve(); if (aSuper instanceof GrTypeDefinition) { if (aSuper.isInterface()) { if (filter.includeMember((GrMember)aSuper)) { result.add(new GrMemberInfo((GrMember)aSuper, true, referenceList)); } } else { extractSuperInterfaces(aSuper, filter, result, processed); } } } } }
extractSuperInterfacesFromReferenceList
30,685
void (GrMember member) { member.accept(new GrClassMemberReferenceVisitor(getClazz()) { @Override protected void visitClassMemberReferenceElement(GrMember classMember, GrReferenceElement ref) { if (!existsInSuperClass(classMember)) { myCollection.add(classMember); } } }); }
collect
30,686
void (GrMember classMember, GrReferenceElement ref) { if (!existsInSuperClass(classMember)) { myCollection.add(classMember); } }
visitClassMemberReferenceElement
30,687
boolean (PsiMember classMember) { if (getSuperClass() == null) return false; if (!(classMember instanceof PsiMethod method)) return false; final PsiMethod methodBySignature = (getSuperClass()).findMethodBySignature(method, true); return methodBySignature != null; }
existsInSuperClass
30,688
boolean (PsiClass baseClass, PsiClass aClass) { return aClass.isInheritor(baseClass, true); }
isInheritor
30,689
void (PsiClass aClass, ArrayList<GrMemberInfo> temp) { GrMemberInfo.extractClassMembers(aClass, temp, myFilter, false); }
extractClassMembers
30,690
boolean (GrMember member1, GrMember member) { if (member instanceof GrMethod && member1 instanceof GrMethod) { return MethodSignatureUtil.areSignaturesEqual((GrMethod)member, (GrMethod)member1); } else if (member instanceof GrField && member1 instanceof GrField || member instanceof GrTypeDefinition && member1 instanceof GrTypeDefinition) { return member.getName().equals(member1.getName()); } return false; }
memberConflict
30,691
void (PsiClass aClass) { if (aClass instanceof GrTypeDefinition) { final GrExtendsClause extendsList = ((GrTypeDefinition)aClass).getExtendsClause(); if (extendsList != null) { buildSubClassesMapForList(extendsList.getReferencedTypes(), (GrTypeDefinition)aClass); } final GrImplementsClause implementsList = ((GrTypeDefinition)aClass).getImplementsClause(); if (implementsList != null) { buildSubClassesMapForList(implementsList.getReferencedTypes(), (GrTypeDefinition)aClass); } } }
buildSubClassesMap
30,692
void (final PsiClassType[] classesList, GrTypeDefinition aClass) { for (PsiClassType element : classesList) { PsiClass resolved = element.resolve(); if (resolved instanceof GrTypeDefinition superClass) { getSubclasses(superClass).add(aClass); buildSubClassesMap(superClass); } } }
buildSubClassesMapForList
30,693
void (@NotNull GrReferenceExpression ref) { GrExpression qualifier = ref.getQualifier(); if (qualifier != null && !(PsiUtil.isThisOrSuperRef(qualifier))) { qualifier.accept(this); if (!(qualifier instanceof GrReferenceExpression) || !(((GrReferenceExpression) qualifier).resolve() instanceof PsiClass)) { return; } } GroovyResolveResult resolveResult = ref.advancedResolve(); PsiElement resolved = resolveResult.getElement(); if (resolved instanceof GrMember) { PsiClass containingClass = ((GrMember)resolved).getContainingClass(); if (isPartOf(myClass, containingClass)) { visitClassMemberReferenceElement(ref, (GrMember)resolved, resolveResult); } } }
visitReferenceExpression
30,694
void (@NotNull GrCodeReferenceElement reference) { GroovyResolveResult resolveResult = reference.advancedResolve(); PsiElement referencedElement = resolveResult.getElement(); if (referencedElement instanceof GrTypeDefinition referencedClass) { if (PsiTreeUtil.isAncestor(myClass, referencedElement, true) || isPartOf(myClass, referencedClass.getContainingClass())) { visitClassMemberReferenceElement(reference, (GrMember)referencedElement, resolveResult); } } }
visitCodeReferenceElement
30,695
boolean (@NotNull PsiClass aClass, @Nullable PsiClass containingClass) { if (containingClass == null) return false; return aClass.equals(containingClass) || aClass.isInheritor(containingClass, true); }
isPartOf
30,696
void (GrReferenceElement<?> ref, GrMember member, GroovyResolveResult resolveResult) { visitClassMemberReferenceElement(member, ref); }
visitClassMemberReferenceElement
30,697
void (GrMember resolved, GrReferenceElement ref) { throw new RuntimeException("Override one of visitClassMemberReferenceElement() methods"); }
visitClassMemberReferenceElement
30,698
boolean (PsiElement element) { return false; }
isEnabledOn
30,699
RefactoringActionHandler (PsiElement element) { return null; }
getHandler