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
31,200
int () { return myMethod.getParameterList().getParametersCount(); }
getParametersCount
31,201
String () { return VisibilityUtil.getVisibilityModifier(myMethod.getModifierList()); }
getVisibility
31,202
GrMethod () { return myMethod; }
getMethod
31,203
boolean () { PsiClass containingClass = myMethod.getContainingClass(); return containingClass != null && !containingClass.isInterface(); }
canChangeVisibility
31,204
boolean () { return true; }
canChangeParameters
31,205
boolean () { return !myMethod.isConstructor(); }
canChangeName
31,206
ReadWriteOption () { return myMethod.isConstructor() ? ReadWriteOption.None : ReadWriteOption.ReadWrite; }
canChangeReturnType
31,207
String () { GrTypeElement returnTypeElement = myMethod.getReturnTypeElementGroovy(); return returnTypeElement != null ? returnTypeElement.getText() : ""; }
getReturnTypeText
31,208
LanguageFileType () { return GroovyFileType.GROOVY_FILE_TYPE; }
getFileType
31,209
GrParameterTableModel (@NotNull GrMethodDescriptor method) { final PsiParameterList parameterList = method.getMethod().getParameterList(); return new GrParameterTableModel(parameterList, myDefaultValueContext, this); }
createParametersInfoModel
31,210
BaseRefactoringProcessor () { final CanonicalTypes.Type type = getReturnType(); final ThrownExceptionInfo[] exceptionInfos = myExceptionsModel.getThrownExceptions(); final GrChangeInfoImpl info = new GrChangeInfoImpl(myMethod.getMethod(), getVisibility(), type, getMethodName(), getParameters(), exceptionInfos, isGenerateDelegate()); return new GrChangeSignatureProcessor(myProject, info); }
createRefactoringProcessor
31,211
void (@NotNull DocumentEvent e) { final int row = table.getSelectedRow(); final int col = table.getSelectedColumn(); myExceptionsModel.setValueAt(cellEditor.getCellEditorValue(), row, col); updateSignature(); }
documentChanged
31,212
PsiCodeFragment () { final JavaCodeFragmentFactory factory = JavaCodeFragmentFactory.getInstance(myProject); return factory.createTypeCodeFragment(myMethod.getReturnTypeText(), myMethod.getMethod(), true, JavaCodeFragmentFactory.ALLOW_VOID); }
createReturnTypeCodeFragment
31,213
CallerChooserBase<PsiMethod> (String title, Tree treeToReuse, Consumer<? super Set<PsiMethod>> callback) { return null; //todo next iteration }
createCallerChooser
31,214
boolean (PsiTypeCodeFragment typeCodeFragment, boolean allowEllipsis) { try { final PsiType type = typeCodeFragment.getType(); return allowEllipsis || !(type instanceof PsiEllipsisType); } catch (PsiTypeCodeFragment.TypeSyntaxException e) { return false; } catch (PsiTypeCodeFragment.NoTypeException e) { return true; //Groovy accepts methods and parameters without explicit type } }
checkType
31,215
String () { if (myReturnTypeCodeFragment != null && !checkType((PsiTypeCodeFragment)myReturnTypeCodeFragment, true)) { return GroovyRefactoringBundle.message("return.type.is.wrong"); } List<GrParameterTableModelItem> parameterInfos = myParametersTableModel.getItems(); int newParameterCount = parameterInfos.size(); for (int i = 0; i < newParameterCount; i++) { GrParameterTableModelItem item = parameterInfos.get(i); String name = item.parameter.getName(); if (!StringUtil.isJavaIdentifier(name)) { return GroovyRefactoringBundle.message("name.is.wrong", name); } if (!checkType((PsiTypeCodeFragment)item.typeCodeFragment, i == newParameterCount - 1)) { return GroovyRefactoringBundle.message("type.for.parameter.is.incorrect", name); } try { item.parameter.setType(((PsiTypeCodeFragment)item.typeCodeFragment).getType()); } catch (PsiTypeCodeFragment.TypeSyntaxException e) { LOG.error(e); } catch (PsiTypeCodeFragment.NoTypeException e) { item.parameter.setType(null); } String defaultValue = item.defaultValueCodeFragment.getText(); final String initializer = item.initializerCodeFragment.getText(); if (item.parameter.getOldIndex() < 0 && defaultValue.trim().isEmpty() && initializer.trim().isEmpty()) { return GroovyRefactoringBundle.message("specify.default.value", name); } item.parameter.setInitializer(initializer); item.parameter.setDefaultValue(defaultValue); } ThrownExceptionInfo[] exceptionInfos = myExceptionsModel.getThrownExceptions(); PsiTypeCodeFragment[] typeCodeFragments = myExceptionsModel.getTypeCodeFragments(); for (int i = 0; i < exceptionInfos.length; i++) { ThrownExceptionInfo exceptionInfo = exceptionInfos[i]; PsiTypeCodeFragment typeCodeFragment = typeCodeFragments[i]; try { PsiType type = typeCodeFragment.getType(); if (!(type instanceof PsiClassType)) { return GroovyRefactoringBundle.message("changeSignature.wrong.type.for.exception", typeCodeFragment.getText()); } PsiElementFactory factory = JavaPsiFacade.getInstance(getProject()).getElementFactory(); PsiClassType throwable = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_THROWABLE, myMethod.getMethod().getResolveScope()); if (!throwable.isAssignableFrom(type)) { return GroovyRefactoringBundle.message("changeSignature.not.throwable.type", typeCodeFragment.getText()); } exceptionInfo.setType((PsiClassType)type); } catch (PsiTypeCodeFragment.TypeSyntaxException e) { return GroovyRefactoringBundle.message("changeSignature.wrong.type.for.exception", typeCodeFragment.getText()); } catch (PsiTypeCodeFragment.NoTypeException e) { return GroovyRefactoringBundle.message("changeSignature.no.type.for.exception"); } } return null; }
validateAndCommitData
31,216
String (GrParameterInfo info) { StringBuilder builder = new StringBuilder(); String typeText = info.getTypeText(); if (typeText.isEmpty()) typeText = GrModifier.DEF; builder.append(typeText).append(' '); builder.append(info.getName()); String initializer = info.getDefaultInitializer(); if (!StringUtil.isEmpty(initializer)) { builder.append(" = ").append(initializer); } return builder.toString(); }
generateParameterText
31,217
String () { String type = myReturnTypeCodeFragment != null ? myReturnTypeCodeFragment.getText().trim() : ""; StringBuilder builder = new StringBuilder(); builder.append(myVisibilityPanel.getVisibility()).append(' '); if (!type.isEmpty()) { builder.append(type).append(' '); } builder.append(GrChangeSignatureUtil.getNameWithQuotesIfNeeded(getMethodName(), getProject())); builder.append('('); final List<GrParameterInfo> infos = getParameters(); if (!infos.isEmpty()) { final List<String> paramsText = ContainerUtil.map(infos, info -> generateParameterText(info)); builder.append("\n").append(INDENT); builder.append(StringUtil.join(paramsText, ",\n" + INDENT)); builder.append('\n'); } builder.append(')'); final PsiTypeCodeFragment[] exceptions = myExceptionsModel.getTypeCodeFragments(); if (exceptions.length > 0) { builder.append("\nthrows\n"); final List<String> exceptionNames = ContainerUtil.map(exceptions, fragment -> fragment.getText()); builder.append(INDENT).append(StringUtil.join(exceptionNames, ",\n" + INDENT)); } return builder.toString(); }
calculateSignature
31,218
VisibilityPanelBase<String> () { return new GroovyComboboxVisibilityPanel(); }
createVisibilityControl
31,219
void (PsiClass clazz, GrMethod prototype, GrMethod refactoredMethod, final MultiMap<PsiElement, String> conflicts, boolean excludeJavaConflicts) { List<MethodSignature> prototypeSignatures = GrClosureSignatureUtil.generateAllSignaturesForMethod(prototype, PsiSubstitutor.EMPTY); checkForClosurePropertySignatureOverload(clazz, prototype, refactoredMethod, conflicts, prototypeSignatures); checkForMethodSignatureOverload(clazz, prototype, refactoredMethod, conflicts, excludeJavaConflicts, prototypeSignatures); checkForAccessorOverloading(clazz, prototype, conflicts); }
checkMethodConflicts
31,220
void (PsiClass clazz, GrMethod prototype, final GrMethod refactoredMethod, final MultiMap<PsiElement, String> conflicts, final List<MethodSignature> prototypeSignatures) { final boolean isStatic = prototype.hasModifierProperty(PsiModifier.STATIC); final String name = prototype.getName(); if (!GroovyPropertyUtils.isProperty(clazz, name, isStatic)) return; final PsiMethod getter = GroovyPropertyUtils.findPropertyGetter(clazz, name, isStatic, true); final PsiType returnType; if (getter instanceof GrMethod) { returnType = ((GrMethod)getter).getInferredReturnType(); } else if (getter instanceof GrAccessorMethod) { returnType = ((GrAccessorMethod)getter).getInferredReturnType(); } else { return; } if (!(returnType instanceof GrClosureType)) return; final List<GrSignature> signatures = ((GrClosureType)returnType).getSignatures(); for (GrSignature signature : signatures) { NextSignature: for (MethodSignature prototypeSignature : prototypeSignatures) { final GrClosureParameter[] params = signature.getParameters(); final PsiType[] types = prototypeSignature.getParameterTypes(); if (types.length != params.length) continue; for (int i = 0; i < types.length; i++) { if (!TypesUtil.isAssignableByMethodCallConversion(types[i], params[i].getType(), refactoredMethod.getParameterList())) { continue NextSignature; } } conflicts.putValue(getter, GroovyRefactoringBundle.message("refactored.method.will.cover.closure.property", name, RefactoringUIUtil.getDescription(getter.getContainingClass(), false))); } } }
checkForClosurePropertySignatureOverload
31,221
void (PsiClass clazz, GrMethod prototype, GrMethod refactoredMethod, MultiMap<PsiElement, String> conflicts, boolean excludeJavaConflicts, List<MethodSignature> prototypeSignatures) { if (excludeJavaConflicts) { prototypeSignatures.remove(prototype.getSignature(PsiSubstitutor.EMPTY)); } String newName = prototype.getName(); PsiMethod[] methods = clazz.findMethodsByName(newName, false); MultiMap<MethodSignature, PsiMethod> signatures = GrClosureSignatureUtil.findRawMethodSignatures(methods, clazz); for (MethodSignature prototypeSignature : prototypeSignatures) { for (PsiMethod method : signatures.get(prototypeSignature)) { if (method != refactoredMethod) { String signaturePresentation = GroovyPresentationUtil.getSignaturePresentation(prototypeSignature); conflicts.putValue(method, GroovyRefactoringBundle.message("method.duplicate", signaturePresentation, RefactoringUIUtil.getDescription(clazz, false))); break; } } } }
checkForMethodSignatureOverload
31,222
void (PsiClass clazz, GrMethod prototype, MultiMap<PsiElement, String> conflicts) { if (GroovyPropertyUtils.isSimplePropertySetter(prototype)) { String propertyName = GroovyPropertyUtils.getPropertyNameBySetter(prototype); PsiMethod setter = GroovyPropertyUtils.findPropertySetter(clazz, propertyName, prototype.hasModifierProperty(PsiModifier.STATIC), false); if (setter instanceof GrAccessorMethod) { conflicts.putValue(setter, GroovyRefactoringBundle.message("replace.setter.for.property", propertyName)); } } else if (GroovyPropertyUtils.isSimplePropertyGetter(prototype)) { boolean isStatic = prototype.hasModifierProperty(PsiModifier.STATIC); String propertyName = GroovyPropertyUtils.getPropertyNameByGetter(prototype); PsiMethod getter = GroovyPropertyUtils.findPropertyGetter(clazz, propertyName, isStatic, false); if (getter instanceof GrAccessorMethod) { conflicts.putValue(getter, GroovyRefactoringBundle.message("replace.getter.for.property", propertyName)); } } }
checkForAccessorOverloading
31,223
GrParameterTableModelItem (@Nullable GrParameterInfo parameterInfo, @NotNull final Project project, @Nullable final PsiElement context) { if (parameterInfo == null) { parameterInfo = new GrParameterInfo("", "", "", null, NEW_PARAMETER, false); } PsiTypeCodeFragment typeCodeFragment = JavaCodeFragmentFactory.getInstance(project).createTypeCodeFragment(parameterInfo.getTypeText(), context, true, JavaCodeFragmentFactory.ALLOW_ELLIPSIS); String initializer = parameterInfo.getDefaultInitializer(); GroovyCodeFragment initializerCodeFragment = new GroovyCodeFragment(project, initializer); GroovyCodeFragment defaultValueCodeFragment = new GroovyCodeFragment(project, parameterInfo.getDefaultValue()); return new GrParameterTableModelItem(parameterInfo, typeCodeFragment, initializerCodeFragment, defaultValueCodeFragment); }
create
31,224
boolean () { try { PsiType type = ((PsiTypeCodeFragment)typeCodeFragment).getType(); return type instanceof PsiArrayType; } catch (PsiTypeCodeFragment.TypeSyntaxException | PsiTypeCodeFragment.NoTypeException e) { return false; } }
isEllipsisType
31,225
void (PsiElement element, final String newName, GroovyPsiElement place, final CollidingVariableVisitor visitor) { visitDownstreamCollisions(newName, place, visitor); visitUpstreamCollisions(element, newName, place, visitor); }
visitLocalsCollisions
31,226
void (PsiElement element, String newName, GroovyPsiElement place, CollidingVariableVisitor visitor) { final GrReferenceExpression refExpr = GroovyPsiElementFactory.getInstance(place.getProject()).createReferenceExpressionFromText(newName, place); final GroovyResolveResult[] results = refExpr.multiResolve(false); for (GroovyResolveResult result : results) { final PsiElement resolved = result.getElement(); if (resolved instanceof GrParameter || (resolved instanceof GrVariable && !(resolved instanceof GrField))) { final PsiElement parent = PsiTreeUtil.findCommonParent(resolved, element); if (parent != null) { PsiElement current = element; while (current != null && current != parent) { if (current instanceof PsiMethod || current instanceof PsiClass || current instanceof GrClosableBlock) { return; } current = current.getParent(); } } if (!place.getManager().areElementsEquivalent(element, resolved)) { visitor.visitCollidingVariable((PsiVariable)resolved); } } } }
visitUpstreamCollisions
31,227
void (final String newName, GroovyPsiElement place, final CollidingVariableVisitor visitor) { place.accept(new GroovyRecursiveElementVisitor() { @Override public void visitVariableDeclaration(@NotNull GrVariableDeclaration variableDeclaration) { final GrVariable[] variables = variableDeclaration.getVariables(); for (GrVariable variable : variables) { if (variable.getName().equals(newName)) { visitor.visitCollidingVariable(variable); } } } @Override public void visitMethod(@NotNull GrMethod method) {} @Override public void visitClosure(@NotNull GrClosableBlock closure) {} @Override public void visitTypeDefinition(@NotNull GrTypeDefinition typeDefinition) {} }); }
visitDownstreamCollisions
31,228
void (@NotNull GrVariableDeclaration variableDeclaration) { final GrVariable[] variables = variableDeclaration.getVariables(); for (GrVariable variable : variables) { if (variable.getName().equals(newName)) { visitor.visitCollidingVariable(variable); } } }
visitVariableDeclaration
31,229
void (@NotNull GrMethod method) {}
visitMethod
31,230
void (@NotNull GrClosableBlock closure) {}
visitClosure
31,231
void (@NotNull GrTypeDefinition typeDefinition) {}
visitTypeDefinition
31,232
UsageInfo[] (ChangeInfo info) { if (info instanceof JavaChangeInfo) { return new GrChageSignatureUsageSearcher((JavaChangeInfo)info).findUsages(); } return UsageInfo.EMPTY_ARRAY; }
findUsages
31,233
boolean (ChangeInfo changeInfo) { if (!(changeInfo instanceof JavaChangeInfo info)) return false; PsiMethod method = info.getMethod(); if (!(method instanceof GrMethod)) return false; if (info.isGenerateDelegate()) { return generateDelegate(info); } return processPrimaryMethodInner(info, ((GrMethod)method), null); }
processPrimaryMethod
31,234
boolean (ChangeInfo changeInfo, UsageInfo[] usages) { if (!StringUtil.isJavaIdentifier(changeInfo.getNewName())) return true; for (UsageInfo usage : usages) { if (usage instanceof GrMethodCallUsageInfo) { if (((GrMethodCallUsageInfo)usage).isPossibleUsage()) return true; } } return false; }
shouldPreviewUsages
31,235
boolean (ChangeInfo changeInfo, Ref<UsageInfo[]> refUsages, Project project) { if (!(changeInfo instanceof JavaChangeInfo)) return true; for (UsageInfo usageInfo : refUsages.get()) { if (usageInfo instanceof GrMethodCallUsageInfo methodCallUsageInfo) { if (methodCallUsageInfo.isToChangeArguments()){ final PsiElement element = methodCallUsageInfo.getElement(); if (element == null) continue; final PsiMethod caller = PsiTreeUtil.getParentOfType(element, PsiMethod.class); final boolean needDefaultValue = !((JavaChangeInfo)changeInfo).getMethodsToPropagateParameters().contains(caller); final PsiMethod referencedMethod = methodCallUsageInfo.getReferencedMethod(); if (needDefaultValue && (caller == null || referencedMethod == null || !MethodSignatureUtil.isSuperMethod(referencedMethod, caller))) { final ParameterInfo[] parameters = changeInfo.getNewParameters(); for (ParameterInfo parameter : parameters) { final String defaultValue = parameter.getDefaultValue(); if (defaultValue == null && parameter.isNew()) { ((ParameterInfoImpl)parameter).setDefaultValue(""); if (!ApplicationManager.getApplication().isUnitTestMode()) { final PsiType type = ((ParameterInfoImpl)parameter).getTypeWrapper().getType(element); final DefaultValueChooser chooser = new DefaultValueChooser(project, parameter.getName(), PsiTypesUtil.getDefaultValueOfType(type)); if (chooser.showAndGet()) { if (chooser.feelLucky()) { parameter.setUseAnySingleVariable(true); } else { ((ParameterInfoImpl)parameter).setDefaultValue(chooser.getDefaultValue()); } } else { return false; } } } } } } } } return true; }
setupDefaultValues
31,236
void (List<? super ResolveSnapshotProvider.ResolveSnapshot> snapshots, @NotNull ResolveSnapshotProvider resolveSnapshotProvider, UsageInfo[] usages, ChangeInfo changeInfo) { }
registerConflictResolvers
31,237
boolean (JavaChangeInfo grInfo) { final GrMethod method = (GrMethod)grInfo.getMethod(); final PsiClass psiClass = method.getContainingClass(); GrMethod newMethod = (GrMethod)method.copy(); newMethod = (GrMethod)psiClass.addAfter(newMethod, method); StringBuilder buffer = new StringBuilder(); buffer.append("\n"); if (method.isConstructor()) { buffer.append("this"); } else { if (!PsiTypes.voidType().equals(method.getReturnType())) { buffer.append("return "); } buffer.append(GrChangeSignatureUtil.getNameWithQuotesIfNeeded(grInfo.getNewName(), method.getProject())); } generateParametersForDelegateCall(grInfo, method, buffer); final GrCodeBlock codeBlock = GroovyPsiElementFactory.getInstance(method.getProject()).createMethodBodyFromText(buffer.toString()); newMethod.setBlock(codeBlock); newMethod.getModifierList().setModifierProperty(PsiModifier.ABSTRACT, false); CodeStyleManager.getInstance(method.getProject()).reformat(newMethod); return processPrimaryMethodInner(grInfo, method, null); }
generateDelegate
31,238
void (JavaChangeInfo grInfo, GrMethod method, StringBuilder buffer) { buffer.append("("); final GrParameter[] oldParameters = method.getParameterList().getParameters(); final JavaParameterInfo[] parameters = grInfo.getNewParameters(); String[] params = new String[parameters.length]; for (int i = 0; i < parameters.length; i++) { JavaParameterInfo parameter = parameters[i]; final int oldIndex = parameter.getOldIndex(); if (oldIndex >= 0) { params[i] = oldParameters[oldIndex].getName(); } else { params[i] = parameter.getDefaultValue(); } } buffer.append(StringUtil.join(params, ",")); buffer.append(");"); }
generateParametersForDelegateCall
31,239
boolean (JavaChangeInfo changeInfo, GrMethod method, @Nullable PsiMethod baseMethod) { if (changeInfo.isNameChanged()) { String newName = baseMethod == null ? changeInfo.getNewName() : RefactoringUtil.suggestNewOverriderName(method.getName(), baseMethod.getName(), changeInfo.getNewName()); if (newName != null && !newName.equals(method.getName())) { method.setName(changeInfo.getNewName()); } } final GrModifierList modifierList = method.getModifierList(); if (changeInfo.isVisibilityChanged()) { modifierList.setModifierProperty(changeInfo.getNewVisibility(), true); } PsiSubstitutor substitutor = baseMethod != null ? calculateSubstitutor(method, baseMethod) : PsiSubstitutor.EMPTY; final PsiMethod context = changeInfo.getMethod(); GrTypeElement oldReturnTypeElement = method.getReturnTypeElementGroovy(); if (changeInfo.isReturnTypeChanged()) { CanonicalTypes.Type newReturnType = changeInfo.getNewReturnType(); if (newReturnType == null) { if (oldReturnTypeElement != null) { oldReturnTypeElement.delete(); if (modifierList.getModifiers().length == 0) { modifierList.setModifierProperty(GrModifier.DEF, true); } } } else { PsiType type = newReturnType.getType(context, method.getManager()); GrReferenceAdjuster.shortenAllReferencesIn(method.setReturnType(substitutor.substitute(type))); if (oldReturnTypeElement == null) { modifierList.setModifierProperty(GrModifier.DEF, false); } } } JavaParameterInfo[] newParameters = changeInfo.getNewParameters(); final GrParameterList parameterList = method.getParameterList(); GrParameter[] oldParameters = parameterList.getParameters(); final PsiParameter[] oldBaseParams = baseMethod != null ? baseMethod.getParameterList().getParameters() : null; Set<GrParameter> toRemove = new HashSet<>(oldParameters.length); ContainerUtil.addAll(toRemove, oldParameters); GrParameter anchor = null; final GrDocComment docComment = method.getDocComment(); final GrDocTag[] tags = docComment == null ? null : docComment.getTags(); int newParamIndex = 0; for (JavaParameterInfo newParameter : newParameters) { //if old parameter name differs from base method parameter name we don't change it final String newName; final int oldIndex = newParameter.getOldIndex(); if (oldIndex >= 0 && oldBaseParams != null) { final String oldName = oldParameters[oldIndex].getName(); if (oldName.equals(oldBaseParams[oldIndex].getName())) { newName = newParameter.getName(); } else { newName = oldName; } } else { newName = newParameter.getName(); } final GrParameter oldParameter = oldIndex >= 0 ? oldParameters[oldIndex] : null; if (docComment != null && oldParameter != null) { final String oldName = oldParameter.getName(); for (GrDocTag tag : tags) { if ("@param".equals(tag.getName())) { final GrDocParameterReference parameterReference = tag.getDocParameterReference(); if (parameterReference != null && oldName.equals(parameterReference.getText())) { parameterReference.handleElementRename(newName); } } } } GrParameter grParameter = createNewParameter(substitutor, context, parameterList, newParameter, newName); if (oldParameter != null) { grParameter.getModifierList().replace(oldParameter.getModifierList()); } if ("def".equals(newParameter.getTypeText())) { grParameter.getModifierList().setModifierProperty(GrModifier.DEF, true); } else if (StringUtil.isEmpty(newParameter.getTypeText())) { grParameter.getModifierList().setModifierProperty(GrModifier.DEF, false); } anchor = (GrParameter)parameterList.addAfter(grParameter, anchor); if (newParamIndex < oldParameters.length) { GrParameter oldParam = oldParameters[newParamIndex]; PsiElement prev = oldParam.getPrevSibling(); if (isWhiteSpaceOrNewLine(prev)) { parameterList.addBefore(prev, anchor); } } newParamIndex++; } for (GrParameter oldParameter : toRemove) { oldParameter.delete(); } JavaCodeStyleManager.getInstance(parameterList.getProject()).shortenClassReferences(parameterList); TextRange parametersRange = parameterList.getParametersRange(); CodeStyleManager.getInstance(parameterList.getProject()).reformatRange( parameterList, parametersRange.getStartOffset(), parametersRange.getEndOffset() ); if (changeInfo.isExceptionSetOrOrderChanged()) { final ThrownExceptionInfo[] infos = changeInfo.getNewExceptions(); PsiClassType[] exceptionTypes = new PsiClassType[infos.length]; for (int i = 0; i < infos.length; i++) { ThrownExceptionInfo info = infos[i]; exceptionTypes[i] = (PsiClassType)info.createType(method, method.getManager()); } PsiReferenceList thrownList = GroovyPsiElementFactory.getInstance(method.getProject()).createThrownList(exceptionTypes); thrownList = (PsiReferenceList)method.getThrowsList().replace(thrownList); JavaCodeStyleManager.getInstance(thrownList.getProject()).shortenClassReferences(thrownList); CodeStyleManager.getInstance(method.getProject()).reformat(method.getThrowsList()); } return true; }
processPrimaryMethodInner
31,240
GrParameter (@NotNull PsiSubstitutor substitutor, @NotNull PsiMethod context, @NotNull GrParameterList parameterList, @NotNull JavaParameterInfo newParameter, @NotNull String newName) { GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(parameterList.getProject()); String typeText = newParameter.getTypeText(); if (newParameter instanceof GrParameterInfo && (typeText.isEmpty() || "def".equals(typeText))) { return factory.createParameter(newName, null, getInitializer(newParameter), parameterList); } PsiType type = substitutor.substitute(newParameter.createType(context, parameterList.getManager())); return factory.createParameter(newName, type == null ? null : type.getCanonicalText(), getInitializer(newParameter), parameterList); }
createNewParameter
31,241
PsiSubstitutor (PsiMethod derivedMethod, PsiMethod baseMethod) { PsiSubstitutor substitutor; if (derivedMethod.getManager().areElementsEquivalent(derivedMethod, baseMethod)) { substitutor = PsiSubstitutor.EMPTY; } else { final PsiClass baseClass = baseMethod.getContainingClass(); final PsiClass derivedClass = derivedMethod.getContainingClass(); if (baseClass != null && derivedClass != null && InheritanceUtil.isInheritorOrSelf(derivedClass, baseClass, true)) { final PsiSubstitutor superClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(baseClass, derivedClass, PsiSubstitutor.EMPTY); final MethodSignature superMethodSignature = baseMethod.getSignature(superClassSubstitutor); final MethodSignature methodSignature = derivedMethod.getSignature(PsiSubstitutor.EMPTY); final PsiSubstitutor superMethodSubstitutor = MethodSignatureUtil.getSuperMethodSignatureSubstitutor(methodSignature, superMethodSignature); substitutor = superMethodSubstitutor != null ? superMethodSubstitutor : superClassSubstitutor; } else { substitutor = PsiSubstitutor.EMPTY; } } return substitutor; }
calculateSubstitutor
31,242
String (JavaParameterInfo newParameter) { if (newParameter instanceof GrParameterInfo) return ((GrParameterInfo)newParameter).getDefaultInitializer(); return null; }
getInitializer
31,243
boolean (ChangeInfo changeInfo, UsageInfo usageInfo, boolean beforeMethodChange, UsageInfo[] usages) { PsiElement element = usageInfo.getElement(); if (element == null) return false; if (!GroovyLanguage.INSTANCE.equals(element.getLanguage())) return false; JavaChangeInfo info = JavaChangeInfoConverters.getJavaChangeInfo(changeInfo, usageInfo); if (info == null) return false; if (beforeMethodChange) { if (usageInfo instanceof OverriderUsageInfo overriderUsageInfo) { PsiMethod method = overriderUsageInfo.getOverridingMethod(); if (!(method instanceof GrMethod grMethod)) return true; processPrimaryMethodInner(info, grMethod, overriderUsageInfo.getBaseMethod()); } } else { if (usageInfo instanceof GrMethodCallUsageInfo methodCallUsageInfo) { processMethodUsage(element, info, methodCallUsageInfo.isToChangeArguments(), methodCallUsageInfo.isToCatchExceptions(), methodCallUsageInfo.getMapToArguments(), methodCallUsageInfo.getSubstitutor()); return true; } else if (usageInfo instanceof DefaultConstructorImplicitUsageInfo constructorImplicitUsageInfo) { processConstructor((GrMethod)constructorImplicitUsageInfo.getConstructor(), info); return true; } else if (usageInfo instanceof NoConstructorClassUsageInfo noConstructorClassUsageInfo) { processClassUsage((GrTypeDefinition)noConstructorClassUsageInfo.getPsiClass(), info); return true; } else if (usageInfo instanceof ChangeSignatureParameterUsageInfo changeSignatureParameterUsageInfo) { String newName = changeSignatureParameterUsageInfo.newParameterName; ((PsiReference)element).handleElementRename(newName); return true; } else { PsiReference ref = element.getReference(); if (ref != null) { ref.bindToElement(info.getMethod()); return true; } } } return false; }
processUsage
31,244
void (GrTypeDefinition psiClass, JavaChangeInfo changeInfo) { String name = psiClass.getName(); GrMethod constructor = GroovyPsiElementFactory.getInstance(psiClass.getProject()) .createConstructorFromText(name, ArrayUtilRt.EMPTY_STRING_ARRAY, ArrayUtilRt.EMPTY_STRING_ARRAY, "{}", null); GrModifierList list = constructor.getModifierList(); if (psiClass.hasModifierProperty(PsiModifier.PRIVATE)) list.setModifierProperty(PsiModifier.PRIVATE, true); if (psiClass.hasModifierProperty(PsiModifier.PROTECTED)) list.setModifierProperty(PsiModifier.PROTECTED, true); if (!list.hasExplicitVisibilityModifiers()) { list.setModifierProperty(GrModifier.DEF, true); } constructor = (GrMethod)psiClass.add(constructor); processConstructor(constructor, changeInfo); }
processClassUsage
31,245
void (GrMethod constructor, JavaChangeInfo changeInfo) { final PsiClass containingClass = constructor.getContainingClass(); final PsiClass baseClass = changeInfo.getMethod().getContainingClass(); final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(baseClass, containingClass, PsiSubstitutor.EMPTY); GrOpenBlock block = constructor.getBlock(); GrConstructorInvocation invocation = GroovyPsiElementFactory.getInstance(constructor.getProject()).createConstructorInvocation("super()"); invocation = (GrConstructorInvocation)block.addStatementBefore(invocation, getFirstStatement(block)); processMethodUsage(invocation.getInvokedExpression(), changeInfo, changeInfo.isParameterSetOrOrderChanged() || changeInfo.isParameterNamesChanged(), changeInfo.isExceptionSetChanged(), GrClosureSignatureUtil.ArgInfo.empty_array(), substitutor); }
processConstructor
31,246
GrStatement (GrCodeBlock block) { GrStatement[] statements = block.getStatements(); if (statements.length == 0) return null; return statements[0]; }
getFirstStatement
31,247
void (PsiElement element, JavaChangeInfo changeInfo, boolean toChangeArguments, boolean toCatchExceptions, GrClosureSignatureUtil.ArgInfo<PsiElement>[] map, PsiSubstitutor substitutor) { if (map == null) return; if (changeInfo.isNameChanged()) { if (element instanceof GrReferenceElement) { element = ((GrReferenceElement<?>)element).handleElementRename(changeInfo.getNewName()); } } if (toChangeArguments) { JavaParameterInfo[] parameters = changeInfo.getNewParameters(); GrArgumentList argumentList = PsiUtil.getArgumentsList(element); GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(element.getProject()); if (argumentList == null) { if (element instanceof GrEnumConstant) { argumentList = factory.createArgumentList(); argumentList = (GrArgumentList)element.add(argumentList); } else { return; } } Set<PsiElement> argsToDelete = new HashSet<>(map.length * 2); for (GrClosureSignatureUtil.ArgInfo<PsiElement> argInfo : map) { argsToDelete.addAll(argInfo.args); } GrExpression[] values = new GrExpression[parameters.length]; for (int i = 0; i < parameters.length; i++) { JavaParameterInfo parameter = parameters[i]; int index = parameter.getOldIndex(); if (index >= 0) { argsToDelete.removeAll(map[index].args); } else { values[i] = createDefaultValue(factory, changeInfo, parameter, argumentList, substitutor); } } for (PsiElement arg : argsToDelete) { arg.delete(); } boolean skipOptionals = false; PsiElement anchor = null; //PsiTreeUtil.getChildOfAnyType(argumentList, GrExpression.class, GrNamedArgument.class); for (int i = 0; i < parameters.length; i++) { JavaParameterInfo parameter = parameters[i]; int index = parameter.getOldIndex(); if (index >= 0) { GrClosureSignatureUtil.ArgInfo<PsiElement> argInfo = map[index]; List<PsiElement> arguments = argInfo.args; if (argInfo.isMultiArg) { //arguments for Map and varArg if ((i != 0 || !(!arguments.isEmpty() && arguments.iterator().next() instanceof GrNamedArgument)) && (i != parameters.length - 1 || !parameter.isVarargType())) { final PsiType type = parameter.createType(changeInfo.getMethod().getParameterList(), argumentList.getManager()); final GrExpression arg = GroovyRefactoringUtil.generateArgFromMultiArg(substitutor, arguments, type, element.getProject()); for (PsiElement argument : arguments) { argument.delete(); } anchor = argumentList.addAfter(arg, anchor); JavaCodeStyleManager.getInstance(anchor.getProject()).shortenClassReferences(anchor); } } else { //arguments for simple parameters if (arguments.size() == 1) { //arg exists PsiElement arg = arguments.iterator().next(); if (i == parameters.length - 1 && parameter.isVarargType()) { if (arg instanceof GrSafeCastExpression) { PsiElement expr = ((GrSafeCastExpression)arg).getOperand(); if (expr instanceof GrListOrMap && !((GrListOrMap)expr).isMap()) { final PsiElement copy = expr.copy(); PsiElement[] newVarargs = ((GrListOrMap)copy).getInitializers(); for (PsiElement vararg : newVarargs) { anchor = argumentList.addAfter(vararg, anchor); } arg.delete(); continue; } } } PsiElement curArg = getNextOfType(argumentList, anchor, GrExpression.class); if (curArg == arg) { anchor = arg; } else { final PsiElement copy = arg.copy(); anchor = argumentList.addAfter(copy, anchor); arg.delete(); } } else { //arg is skipped. Parameter is optional skipOptionals = true; } } } else { if (skipOptionals && isParameterOptional(parameter)) continue; if (forceOptional(parameter)) { skipOptionals = true; continue; } try { final GrExpression value = values[i]; if (i > 0 && (value == null || anchor == null)) { PsiElement comma = Factory.createSingleLeafElement(GroovyTokenTypes.mCOMMA, ",", 0, 1, SharedImplUtil.findCharTableByTree(argumentList.getNode()), argumentList.getManager()).getPsi(); if (anchor == null) anchor = argumentList.getLeftParen(); anchor = argumentList.addAfter(comma, anchor); } if (value != null) { anchor = argumentList.addAfter(value, anchor); } } catch (IncorrectOperationException e) { LOG.error(e.getMessage()); } } } for (PsiElement arg : argsToDelete) { arg.delete(); } GrCall call = GroovyRefactoringUtil.getCallExpressionByMethodReference(element); if (argumentList.getText().trim().isEmpty() && (call == null || !call.hasClosureArguments())) { argumentList = argumentList.replaceWithArgumentList(factory.createArgumentList()); } CodeStyleManager.getInstance(argumentList.getProject()).reformat(argumentList); } if (toCatchExceptions) { final ThrownExceptionInfo[] exceptionInfos = changeInfo.getNewExceptions(); PsiClassType[] exceptions = getExceptions(exceptionInfos, element, element.getManager()); fixExceptions(element, exceptions); } }
processMethodUsage
31,248
GrExpression (GroovyPsiElementFactory factory, JavaChangeInfo changeInfo, JavaParameterInfo info, final GrArgumentList list, PsiSubstitutor substitutor) { if (info.isUseAnySingleVariable()) { final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(list.getProject()).getResolveHelper(); final PsiType type = info.getTypeWrapper().getType(changeInfo.getMethod(), list.getManager()); final VariablesProcessor processor = new VariablesProcessor(false) { @Override protected boolean check(PsiVariable var, ResolveState state) { if (var instanceof PsiField && !resolveHelper.isAccessible((PsiField)var, list, null)) return false; if (var instanceof GrVariable && PsiUtil.isLocalVariable(var) && list.getTextRange().getStartOffset() <= var.getTextRange().getStartOffset()) { return false; } if (PsiTreeUtil.isAncestor(var, list, false)) return false; final PsiType _type = var instanceof GrVariable ? ((GrVariable)var).getTypeGroovy() : var.getType(); final PsiType varType = state.get(PsiSubstitutor.KEY).substitute(_type); return type.isAssignableFrom(varType); } @Override public boolean execute(@NotNull PsiElement pe, @NotNull ResolveState state) { super.execute(pe, state); return size() < 2; } }; treeWalkUp(list, processor); if (processor.size() == 1) { final PsiVariable result = processor.getResult(0); return factory.createExpressionFromText(result.getName(), list); } if (processor.size() == 0) { final PsiClass parentClass = PsiTreeUtil.getParentOfType(list, PsiClass.class); if (parentClass != null) { PsiClass containingClass = parentClass; final Set<PsiClass> containingClasses = new HashSet<>(); final PsiElementFactory jfactory = JavaPsiFacade.getElementFactory(list.getProject()); while (containingClass != null) { if (type.isAssignableFrom(jfactory.createType(containingClass, PsiSubstitutor.EMPTY))) { containingClasses.add(containingClass); } containingClass = PsiTreeUtil.getParentOfType(containingClass, PsiClass.class); } if (containingClasses.size() == 1) { return factory.createThisExpression(containingClasses.contains(parentClass) ? null : containingClasses.iterator().next()); } } } } final PsiElement element = info.getActualValue(list.getParent(), substitutor); if (element instanceof GrExpression) { return (GrExpression)element; } final String value = info.getDefaultValue(); return !StringUtil.isEmpty(value) ? factory.createExpressionFromText(value, list) : null; }
createDefaultValue
31,249
boolean (PsiVariable var, ResolveState state) { if (var instanceof PsiField && !resolveHelper.isAccessible((PsiField)var, list, null)) return false; if (var instanceof GrVariable && PsiUtil.isLocalVariable(var) && list.getTextRange().getStartOffset() <= var.getTextRange().getStartOffset()) { return false; } if (PsiTreeUtil.isAncestor(var, list, false)) return false; final PsiType _type = var instanceof GrVariable ? ((GrVariable)var).getTypeGroovy() : var.getType(); final PsiType varType = state.get(PsiSubstitutor.KEY).substitute(_type); return type.isAssignableFrom(varType); }
check
31,250
boolean (@NotNull PsiElement pe, @NotNull ResolveState state) { super.execute(pe, state); return size() < 2; }
execute
31,251
boolean (JavaParameterInfo parameter) { return parameter instanceof GrParameterInfo && ((GrParameterInfo)parameter).forceOptional(); }
forceOptional
31,252
void (PsiElement element, PsiClassType[] exceptions) { if (exceptions.length == 0) return; final GroovyPsiElement context = PsiTreeUtil.getParentOfType(element, GrTryCatchStatement.class, GrClosableBlock.class, GrMethod.class, GroovyFile.class); if (context instanceof GrClosableBlock) { element = generateTryCatch(element, exceptions); } else if (context instanceof GrMethod) { final PsiClassType[] handledExceptions = ((GrMethod)context).getThrowsList().getReferencedTypes(); final List<PsiClassType> psiClassTypes = filterOutExceptions(exceptions, context, handledExceptions); element = generateTryCatch(element, psiClassTypes.toArray(PsiClassType.EMPTY_ARRAY)); } else if (context instanceof GroovyFile) { element = generateTryCatch(element, exceptions); } else if (context instanceof GrTryCatchStatement) { final GrCatchClause[] catchClauses = ((GrTryCatchStatement)context).getCatchClauses(); List<PsiClassType> referencedTypes = ContainerUtil.map(catchClauses, grCatchClause -> { final GrParameter grParameter = grCatchClause.getParameter(); final PsiType type = grParameter != null ? grParameter.getType() : null; if (type instanceof PsiClassType) { return (PsiClassType)type; } else { return null; } }); referencedTypes = ContainerUtil.skipNulls(referencedTypes); final List<PsiClassType> psiClassTypes = filterOutExceptions(exceptions, context, referencedTypes.toArray(PsiClassType.EMPTY_ARRAY)); element = fixCatchBlock((GrTryCatchStatement)context, psiClassTypes.toArray(PsiClassType.EMPTY_ARRAY)); } // CodeStyleManager.getInstance(element.getProject()).reformat(element); }
fixExceptions
31,253
PsiElement (PsiElement element, PsiClassType[] exceptions) { if (exceptions.length == 0) return element; GrTryCatchStatement tryCatch = (GrTryCatchStatement)GroovyPsiElementFactory.getInstance(element.getProject()).createStatementFromText("try{} catch (Exception e){}"); final GrStatement statement = PsiTreeUtil.getParentOfType(element, GrStatement.class); assert statement != null; final GrOpenBlock block = tryCatch.getTryBlock(); assert block != null; block.addStatementBefore(statement, null); tryCatch = (GrTryCatchStatement)statement.replace(tryCatch); tryCatch.getCatchClauses()[0].delete(); fixCatchBlock(tryCatch, exceptions); return tryCatch; }
generateTryCatch
31,254
PsiElement (GrTryCatchStatement tryCatch, PsiClassType[] exceptions) { if (exceptions.length == 0) return tryCatch; final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(tryCatch.getProject()); final GrCatchClause[] clauses = tryCatch.getCatchClauses(); List<String> restricted = ContainerUtil.map(clauses, grCatchClause -> { final GrParameter grParameter = grCatchClause.getParameter(); return grParameter != null ? grParameter.getName() : null; }); restricted = ContainerUtil.skipNulls(restricted); final DefaultGroovyVariableNameValidator nameValidator = new DefaultGroovyVariableNameValidator(tryCatch, restricted); GrCatchClause anchor = clauses.length == 0 ? null : clauses[clauses.length - 1]; for (PsiClassType type : exceptions) { final String[] names = GroovyNameSuggestionUtil.suggestVariableNameByType(type, nameValidator); final GrCatchClause catchClause = factory.createCatchClause(type, names[0]); final GrStatement printStackTrace = factory.createStatementFromText(names[0] + ".printStackTrace()"); catchClause.getBody().addStatementBefore(printStackTrace, null); anchor = tryCatch.addCatchClause(catchClause, anchor); JavaCodeStyleManager.getInstance(anchor.getProject()).shortenClassReferences(anchor); } return tryCatch; }
fixCatchBlock
31,255
List<PsiClassType> (PsiClassType[] exceptions, final GroovyPsiElement context, final PsiClassType[] handledExceptions) { return ContainerUtil.findAll(exceptions, o -> { if (!InheritanceUtil.isInheritor(o, CommonClassNames.JAVA_LANG_EXCEPTION)) return false; for (PsiClassType type : handledExceptions) { if (TypesUtil.isAssignableByMethodCallConversion(type, o, context)) return false; } return true; }); }
filterOutExceptions
31,256
PsiClassType[] (ThrownExceptionInfo[] infos, final PsiElement context, final PsiManager manager) { return ContainerUtil.map(infos, thrownExceptionInfo -> (PsiClassType)thrownExceptionInfo.createType(context, manager), new PsiClassType[infos.length]); }
getExceptions
31,257
boolean (JavaParameterInfo parameterInfo) { return parameterInfo instanceof GrParameterInfo && ((GrParameterInfo)parameterInfo).isOptional(); }
isParameterOptional
31,258
GrChangeInfoImpl () { return (GrChangeInfoImpl)super.getChangeInfo(); }
getChangeInfo
31,259
UsageViewDescriptor (UsageInfo @NotNull [] usages) { return new ChangeSignatureViewDescriptor(getChangeInfo().getMethod()); }
createUsageViewDescriptor
31,260
void (PsiElement @NotNull [] elements) { boolean condition = elements.length == 1 && elements[0] instanceof PsiMethod; LOG.assertTrue(condition); getChangeInfo().updateMethod((PsiMethod)elements[0]); }
refreshElements
31,261
boolean (@NotNull Ref<UsageInfo[]> refUsages) { MultiMap<PsiElement, String> conflictDescriptions = new MultiMap<>(); collectConflictsFromExtensions(refUsages, conflictDescriptions, myChangeInfo); final UsageInfo[] usagesIn = refUsages.get(); RenameUtil.addConflictDescriptions(usagesIn, conflictDescriptions); Set<UsageInfo> usagesSet = ContainerUtil.newHashSet(usagesIn); RenameUtil.removeConflictUsages(usagesSet); if (!conflictDescriptions.isEmpty()) { if (ApplicationManager.getApplication().isUnitTestMode()) { throw new ConflictsInTestsException(conflictDescriptions.values()); } ConflictsDialogBase dialog = prepareConflictsDialog(conflictDescriptions, usagesIn); if (!dialog.showAndGet()) { if (dialog.isShowConflicts()) prepareSuccessful(); return false; } } refUsages.set(usagesSet.toArray(UsageInfo.EMPTY_ARRAY)); prepareSuccessful(); return true; }
preprocessUsages
31,262
boolean (GrParameterTableModelItem item) { boolean isGenerateDelegate = dialog.isGenerateDelegate(); return !isGenerateDelegate && super.isCellEditable(item); }
isCellEditable
31,263
GrParameterTableModelItem (@Nullable GrParameterInfo parameterInfo) { return GrParameterTableModelItem.create(parameterInfo, myTypeContext.getProject(), myDefaultValueContext); }
createRowItem
31,264
TableCellEditor (GrParameterTableModelItem o) { return new JavaCodeFragmentTableCellEditor(myProject); }
doCreateEditor
31,265
TableCellEditor (GrParameterTableModelItem item) { return new GrCodeFragmentTableCellEditor(myProject); }
doCreateEditor
31,266
String () { return GroovyBundle.message("change.signature.default.initializer.column"); }
getName
31,267
boolean (GrParameterTableModelItem item) { return true; }
isCellEditable
31,268
PsiCodeFragment (GrParameterTableModelItem item) { return item.initializerCodeFragment; }
valueOf
31,269
void (@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) { editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); PsiElement element = findTargetMember(file, editor); if (element == null) { element = CommonDataKeys.PSI_ELEMENT.getData(dataContext); } invokeOnElement(project, editor, element); }
invoke
31,270
void (Project project, Editor editor, PsiElement element) { if (element instanceof PsiMethod) { invoke((PsiMethod)element, project); } else { String message = RefactoringBundle.getCannotRefactorMessage(GroovyRefactoringBundle.message("error.wrong.caret.position.method.name")); CommonRefactoringUtil.showErrorHint(project, editor, message, RefactoringBundle.message("changeSignature.refactoring.name"), HelpID.CHANGE_SIGNATURE); } }
invokeOnElement
31,271
void (@NotNull final Project project, final PsiElement @NotNull [] elements, final DataContext dataContext) { if (elements.length != 1) return; Editor editor = dataContext == null ? null : CommonDataKeys.EDITOR.getData(dataContext); invokeOnElement(project, editor, elements[0]); }
invoke
31,272
String () { return null; }
getTargetNotFoundMessage
31,273
void (PsiMethod method, final Project project) { if (!CommonRefactoringUtil.checkReadOnlyStatus(project, method)) return; if (method instanceof GrReflectedMethod) method = ((GrReflectedMethod)method).getBaseMethod(); PsiMethod newMethod = SuperMethodWarningUtil.checkSuperMethod(method); if (newMethod == null) return; if (!newMethod.equals(method)) { ChangeSignatureUtil.invokeChangeSignatureOn(newMethod, project); return; } if (!CommonRefactoringUtil.checkReadOnlyStatus(project, method)) return; if (!(method instanceof GrMethod)) return; //todo final GrChangeSignatureDialog dialog = new GrChangeSignatureDialog(project, new GrMethodDescriptor((GrMethod)method), true, null); dialog.show(); }
invoke
31,274
PsiElement (@NotNull PsiFile file, @NotNull Editor editor) { final PsiElement element = file.findElementAt(editor.getCaretModel().getOffset()); final PsiElement targetMember = findTargetMember(element); if (targetMember != null) return targetMember; final PsiReference reference = file.findReferenceAt(editor.getCaretModel().getOffset()); if (reference != null) { return reference.resolve(); } return null; }
findTargetMember
31,275
PsiElement (@Nullable PsiElement element) { if (element == null) return null; final GrParameterList parameterList = PsiTreeUtil.getParentOfType(element, GrParameterList.class); if (parameterList != null) { final PsiElement parent = parameterList.getParent(); if (parent instanceof PsiMethod) return parent; } if (element.getParent() instanceof GrMethod && ((GrMethod)element.getParent()).getNameIdentifierGroovy() == element) { return element.getParent(); } final GrCall expression = PsiTreeUtil.getParentOfType(element, GrCall.class); if (expression != null) { return expression.resolveMethod(); } final PsiReference ref = element.getReference(); if (ref == null) return null; return ref.resolve(); }
findTargetMember
31,276
boolean () { return myToCatchExceptions; }
isToCatchExceptions
31,277
boolean () { return myToChangeArguments; }
isToChangeArguments
31,278
PsiMethod () { final GroovyResolveResult result = resolveMethod(getElement()); if (result == null) return null; final PsiElement element = result.getElement(); return element instanceof PsiMethod ? (PsiMethod)element : null; }
getReferencedMethod
31,279
GroovyResolveResult (final PsiElement ref) { if (ref instanceof GrEnumConstant) return ((GrEnumConstant)ref).advancedResolve(); PsiElement parent = ref.getParent(); if (parent instanceof GrMethodCall) { final GrExpression expression = ((GrMethodCall)parent).getInvokedExpression(); if (expression instanceof GrReferenceExpression) { return ((GrReferenceExpression)expression).advancedResolve(); } } else if (parent instanceof GrConstructorCall) { return ((GrConstructorCall)parent).advancedResolve(); } return null; }
resolveMethod
31,280
PsiSubstitutor () { return mySubstitutor; }
getSubstitutor
31,281
boolean () { final GroovyResolveResult resolveResult = resolveMethod(getElement()); return resolveResult == null || resolveResult.getElement() == null; }
isPossibleUsage
31,282
boolean () { return myMapToArguments != null; }
isCorrect
31,283
String () { return visibilityModifier; }
getNewVisibility
31,284
boolean () { return myAreParametersChanged; }
isParameterSetOrOrderChanged
31,285
boolean () { return myIsParameterTypesChanged; }
isParameterTypesChanged
31,286
boolean () { return myIsParameterNamesChanged; }
isParameterNamesChanged
31,287
boolean () { return myDelegate; }
isGenerateDelegate
31,288
boolean () { return myIsNameChanged; }
isNameChanged
31,289
boolean () { return myIsVisibilityChanged; }
isVisibilityChanged
31,290
boolean () { return myExceptionSetChanged; }
isExceptionSetChanged
31,291
boolean () { return myExceptionSetOrOrderChanged; }
isExceptionSetOrOrderChanged
31,292
GrMethod () { return method; }
getMethod
31,293
boolean () { return myIsReturnTypeChanged; }
isReturnTypeChanged
31,294
String () { return newName; }
getNewName
31,295
Language () { return GroovyLanguage.INSTANCE; }
getLanguage
31,296
ThrownExceptionInfo[] () { return myThrownExceptions; }
getNewExceptions
31,297
boolean () { return myIsRetainVarargs; }
isRetainsVarargs
31,298
boolean () { return myIsObtainVarargs; }
isObtainsVarags
31,299
boolean () { return myIsArrayToVarargs; }
isArrayToVarargs