@NotNull @Override public Collection<PsiReference> findReferences(PsiElement element) { assert element instanceof GrField; ArrayList<PsiReference> refs = new ArrayList<>(); GrField field = (GrField) element; GlobalSearchScope projectScope = GlobalSearchScope.projectScope(element.getProject()); PsiMethod setter = field.getSetter(); if (setter != null) { refs.addAll( RenameAliasedUsagesUtil.filterAliasedRefs( MethodReferencesSearch.search(setter, projectScope, true).findAll(), setter)); } GrAccessorMethod[] getters = field.getGetters(); for (GrAccessorMethod getter : getters) { refs.addAll( RenameAliasedUsagesUtil.filterAliasedRefs( MethodReferencesSearch.search(getter, projectScope, true).findAll(), getter)); } refs.addAll( RenameAliasedUsagesUtil.filterAliasedRefs( ReferencesSearch.search(field, projectScope, false).findAll(), field)); return refs; }
public static void collectMethodsFromBody( @NotNull GrTypeDefinition definition, List<PsiMethod> result) { for (GrMethod method : definition.getCodeMethods()) { addExpandingReflectedMethods(result, method); } for (GrField field : definition.getFields()) { if (!field.isProperty()) continue; ContainerUtil.addAll(result, field.getGetters()); ContainerUtil.addIfNotNull(result, field.getSetter()); } }
private void processPropertyFromField( @NotNull GrField field, @NotNull GroovyResolveResult resolveResult) { if (field.getGetters().length != 0 || field.getSetter() != null || !myPropertyNames.add(field.getName()) || myIsMap) return; for (LookupElement element : GroovyCompletionUtil.createLookupElements(resolveResult, false, myMatcher, null)) { myConsumer.consume( ((LookupElementBuilder) element).withIcon(JetgroovyIcons.Groovy.Property)); } }
public void putNewElements(@NotNull GrField field) { myNewElements.put(field.getName(), field); if (field.isProperty()) { for (GrAccessorMethod newGetter : field.getGetters()) { myNewElements.put(newGetter.getName(), newGetter); } final GrAccessorMethod newSetter = field.getSetter(); if (newSetter != null) { myNewElements.put(newSetter.getName(), newSetter); } } }
public NameProvider(GrField field, String newName) { myNameMap.put(field, newName); if (field.isProperty()) { for (GrAccessorMethod getter : field.getGetters()) { myNameMap.put( getter, RenamePropertyUtil.getGetterNameByOldName(newName, getter.getName())); } final GrAccessorMethod setter = field.getSetter(); if (setter != null) { myNameMap.put(setter, GroovyPropertyUtils.getSetterName(newName)); } } }
@Override protected void processIntention(@NotNull PsiElement element, Project project, Editor editor) throws IncorrectOperationException { final GrField field; if (element.getParent() instanceof GrField) { field = (GrField) element.getParent(); } else { final PsiReference ref = element.getReference(); LOG.assertTrue(ref != null); PsiElement resolved = ref.resolve(); if (resolved instanceof GrAccessorMethod) { resolved = ((GrAccessorMethod) resolved).getProperty(); } LOG.assertTrue(resolved instanceof GrField); field = (GrField) resolved; } final HashSet<PsiReference> usages = new HashSet<PsiReference>(); usages.addAll(ReferencesSearch.search(field).findAll()); final GrAccessorMethod[] getters = field.getGetters(); for (GrAccessorMethod getter : getters) { usages.addAll(MethodReferencesSearch.search(getter).findAll()); } final GrAccessorMethod setter = field.getSetter(); if (setter != null) { usages.addAll(MethodReferencesSearch.search(setter).findAll()); } final String fieldName = field.getName(); LOG.assertTrue(fieldName != null); final Collection<PsiElement> fieldUsages = new HashSet<PsiElement>(); MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>(); for (PsiReference usage : usages) { final PsiElement psiElement = usage.getElement(); if (PsiUtil.isMethodUsage(psiElement)) continue; if (!GroovyFileType.GROOVY_LANGUAGE.equals(psiElement.getLanguage())) { conflicts.putValue( psiElement, GroovyIntentionsBundle.message("closure.is.accessed.outside.of.groovy", fieldName)); } else { if (psiElement instanceof GrReferenceExpression) { fieldUsages.add(psiElement); if (PsiUtil.isAccessedForWriting((GrExpression) psiElement)) { conflicts.putValue( psiElement, GroovyIntentionsBundle.message("write.access.to.closure.variable", fieldName)); } } else if (psiElement instanceof GrArgumentLabel) { conflicts.putValue( psiElement, GroovyIntentionsBundle.message("field.is.used.in.argument.label", fieldName)); } } } final PsiClass containingClass = field.getContainingClass(); final GrExpression initializer = field.getInitializerGroovy(); LOG.assertTrue(initializer != null); final PsiType type = initializer.getType(); LOG.assertTrue(type instanceof GrClosureType); final GrSignature signature = ((GrClosureType) type).getSignature(); final List<MethodSignature> signatures = GrClosureSignatureUtil.generateAllMethodSignaturesBySignature(fieldName, signature); for (MethodSignature s : signatures) { final PsiMethod method = MethodSignatureUtil.findMethodBySignature(containingClass, s, true); if (method != null) { conflicts.putValue( method, GroovyIntentionsBundle.message( "method.with.signature.already.exists", GroovyPresentationUtil.getSignaturePresentation(s))); } } if (conflicts.size() > 0) { final ConflictsDialog conflictsDialog = new ConflictsDialog( project, conflicts, new Runnable() { @Override public void run() { execute(field, fieldUsages); } }); conflictsDialog.show(); if (conflictsDialog.getExitCode() != DialogWrapper.OK_EXIT_CODE) return; } execute(field, fieldUsages); }