Java PropertyUtil.findPropertySetter方法代码示例

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
public PsiMember fromString(final String s, final ConvertContext context) {
  if (s == null) return null;
  final PsiClass psiClass = getTargetClass(context);
  if (psiClass == null) return null;
  for (PropertyMemberType type : getMemberTypes(context)) {
    switch (type) {
      case FIELD:
        final PsiField field = psiClass.findFieldByName(s, isLookDeep());
        if (field != null) return field;
        break;
      case GETTER:
        final PsiMethod getter = PropertyUtil.findPropertyGetter(psiClass, getPropertyName(s, context), false, isLookDeep());
        if (getter != null) return getter;
        break;
      case SETTER:
        final PsiMethod setter = PropertyUtil.findPropertySetter(psiClass, getPropertyName(s, context), false, isLookDeep());
        if (setter != null) return setter;
        break;
    }
  }
  return null;
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
  if (!myField.isValid()) return false;

  final PsiClass aClass = myField.getContainingClass();
  if (aClass == null) {
    return false;
  }

  if (myCreateGetter){
    if (isStaticFinal(myField) || PropertyUtil.findPropertyGetter(aClass, myPropertyName, isStatic(myField), false) != null){
      return false;
    }
  }

  if (myCreateSetter){
    if(isFinal(myField) || PropertyUtil.findPropertySetter(aClass, myPropertyName, isStatic(myField), false) != null){
      return false;
    }
  }

  return true;
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
private static boolean isSetterNonNls(final Project project, final GlobalSearchScope searchScope,
                                      final String componentClassName, final String propertyName) {
  PsiClass componentClass = JavaPsiFacade.getInstance(project).findClass(componentClassName, searchScope);
  if (componentClass == null) {
    return false;
  }
  PsiMethod setter = PropertyUtil.findPropertySetter(componentClass, propertyName, false, true);
  if (setter != null) {
    PsiParameter[] parameters = setter.getParameterList().getParameters();
    if (parameters.length == 1 &&
        "java.lang.String".equals(parameters[0].getType().getCanonicalText()) &&
        AnnotationUtil.isAnnotated(parameters [0], AnnotationUtil.NON_NLS, false, true)) {
      return true;
    }
  }

  return false;
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@Override
public void visitField(@NotNull PsiField field) {
  final Project project = field.getProject();
  final String propertyName = PropertyUtil.suggestPropertyName(project, field);
  final boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
  final PsiClass containingClass = field.getContainingClass();
  final PsiMethod setter = PropertyUtil.findPropertySetter(containingClass, propertyName, isStatic, false);
  if (setter == null) {
    return;
  }
  final PsiMethod getter = PropertyUtil.findPropertyGetter(containingClass, propertyName, isStatic, false);
  if (getter != null) {
    return;
  }
  registerFieldError(field);
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@Override
protected void process(List<ClassMember> classMembers) {
  for (ClassMember classMember : classMembers) {
    final PsiElementClassMember elementClassMember = (PsiElementClassMember) classMember;

    PsiField psiField = (PsiField) elementClassMember.getPsiElement();
    PsiMethod psiMethod = PropertyUtil.findPropertySetter(psiField.getContainingClass(), psiField.getName(), false, false);
    if (null != psiMethod) {
      PsiModifierList modifierList = psiField.getModifierList();
      if (null != modifierList) {
        PsiAnnotation psiAnnotation = modifierList.addAnnotation(Setter.class.getName());

        psiMethod.delete();
      }
    }
  }
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
private static boolean isSetter(PsiAssignmentExpression expression)
{
	final PsiExpression lExpression = expression.getLExpression();
	if(lExpression instanceof PsiReferenceExpression)
	{
		final PsiElement resolved = ((PsiReferenceExpression) lExpression).resolve();
		if(resolved instanceof PsiField)
		{
			PsiField field = (PsiField) resolved;
			final NavigatablePsiElement containingMethod = PsiTreeUtil.getParentOfType(expression, PsiMethod.class, PsiLambdaExpression.class);
			if(containingMethod instanceof PsiMethod)
			{
				final PsiMethod setter = PropertyUtil.findPropertySetter(field.getContainingClass(), field.getName(), field.hasModifierProperty(PsiModifier.STATIC), false);
				if(containingMethod.isEquivalentTo(setter))
				{
					return true;
				}
			}
		}
	}
	return false;
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@NotNull
public static Optional<PsiField> findSettablePsiField(@NotNull PsiClass clazz,
    @Nullable String propertyName) {
  PsiMethod propertySetter = PropertyUtil.findPropertySetter(clazz, propertyName, false, true);
  return null == propertySetter ?
      Optional.empty() :
      Optional.ofNullable(PropertyUtil.findPropertyFieldByMember(propertySetter));
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@Nullable
public PsiMethod getSetter() {
  if (PropertyUtil.isSimplePropertySetter(myMethod)) {
    return myMethod;
  }
  return PropertyUtil.findPropertySetter(myMethod.getContainingClass(), getName(), false, true);
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
public Collection<PsiElement> getAdditionalElementsToDelete(@NotNull final PsiElement element,
                                                            @NotNull final Collection<PsiElement> allElementsToDelete,
                                                            final boolean askUser) {
  if (element instanceof PsiField) {
    PsiField field = (PsiField)element;
    final Project project = element.getProject();
    String propertyName = JavaCodeStyleManager.getInstance(project).variableNameToPropertyName(field.getName(), VariableKind.FIELD);

    PsiClass aClass = field.getContainingClass();
    if (aClass != null) {
      boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
      PsiMethod[] getters = GetterSetterPrototypeProvider.findGetters(aClass, propertyName, isStatic);
      if (getters != null) {
        final List<PsiMethod> validGetters = new ArrayList<PsiMethod>(1);
        for (PsiMethod getter : getters) {
          if (!allElementsToDelete.contains(getter) && (getter != null && getter.isPhysical())) {
            validGetters.add(getter);
          }
        }
        getters = validGetters.isEmpty() ? null : validGetters.toArray(new PsiMethod[validGetters.size()]);
      }

      PsiMethod setter = PropertyUtil.findPropertySetter(aClass, propertyName, isStatic, false);
      if (allElementsToDelete.contains(setter) || setter != null && !setter.isPhysical()) setter = null;
      if (askUser && (getters != null || setter != null)) {
        final String message =
          RefactoringMessageUtil.getGetterSetterMessage(field.getName(), RefactoringBundle.message("delete.title"), getters != null ? getters[0] : null, setter);
        if (!ApplicationManager.getApplication().isUnitTestMode() && Messages.showYesNoDialog(project, message, RefactoringBundle.message("safe.delete.title"), Messages.getQuestionIcon()) != Messages.YES) {
          getters = null;
          setter = null;
        }
      }
      List<PsiElement> elements = new ArrayList<PsiElement>();
      if (setter != null) elements.add(setter);
      if (getters != null) Collections.addAll(elements, getters);
      return elements;
    }
  }
  return null;
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
public Object getData(final String dataId) {
  if(getClass().getName().equals(dataId)){
    return this;
  }
  else if(CommonDataKeys.PSI_ELEMENT.is(dataId)){
    final IntrospectedProperty introspectedProperty = getSelectedIntrospectedProperty();
    if(introspectedProperty == null){
      return null;
    }
    final PsiClass aClass = getComponentClass();
    if(aClass == null){
      return null;
    }

    final PsiMethod getter = PropertyUtil.findPropertyGetter(aClass, introspectedProperty.getName(), false, true);
    if(getter != null){
      return getter;
    }

    return PropertyUtil.findPropertySetter(aClass, introspectedProperty.getName(), false, true);
  }
  else if (CommonDataKeys.PSI_FILE.is(dataId) && myEditor != null) {
    return PsiManager.getInstance(myEditor.getProject()).findFile(myEditor.getFile());
  }
  else if (GuiEditor.DATA_KEY.is(dataId)) {
    return myEditor;
  }
  else if (PlatformDataKeys.FILE_EDITOR.is(dataId)) {
    GuiEditor designer = DesignerToolWindowManager.getInstance(myProject).getActiveFormEditor();
    return designer == null ? null : designer.getEditor();
  }
  else if (PlatformDataKeys.HELP_ID.is(dataId)) {
    return ourHelpID;
  }
  else {
    return null;
  }
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@Override
public void visitField(@NotNull PsiField field) {
  final String propertyName = PropertyUtil.suggestPropertyName(field);
  final boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
  final PsiClass containingClass = field.getContainingClass();
  final PsiMethod setter = PropertyUtil.findPropertySetter(containingClass, propertyName, isStatic, false);
  if (setter == null) {
    return;
  }
  final PsiMethod getter = PropertyUtil.findPropertyGetter(containingClass, propertyName, isStatic, false);
  if (getter != null) {
    return;
  }
  registerFieldError(field);
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
  final GrArgumentLabel context = getElement();
  final GrNamedArgument namedArgument = (GrNamedArgument) context.getParent();
  final GrExpression map = (GrExpression)namedArgument.getParent();
  final PsiClassType classType = LiteralConstructorReference.getTargetConversionType(map);
  if (classType != null) {
    final PsiClass psiClass = classType.resolve();
    if (psiClass != null) {
      final GrExpression value = namedArgument.getExpression();

      final List<ResolveResult> applicable = addMethodCandidates(classType, value);

      final String memberName = getValue();
      if (value == null || applicable.isEmpty()) {
        final PsiMethod setter = PropertyUtil.findPropertySetter(psiClass, memberName, false, true);
        if (setter != null) {
          applicable.add(new PsiElementResolveResult(setter));
        } else {
          final PsiField field = PropertyUtil.findPropertyField(psiClass, memberName, false);
          if (field != null) {
            applicable.add(new PsiElementResolveResult(field));
          }
        }
      }

      return applicable.toArray(new ResolveResult[applicable.size()]);
    }
  }

  return ResolveResult.EMPTY_ARRAY;
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
@Override
public void findExistingNameConflicts(PsiElement element, String newName, MultiMap<PsiElement, String> conflicts) {
  super.findExistingNameConflicts(element, newName, conflicts);

  GrField field = (GrField)element;
  final PsiClass containingClass = field.getContainingClass();
  if (containingClass == null) return;

  final PsiMethod getter = GroovyPropertyUtils.findGetterForField(field);
  if (getter instanceof GrAccessorMethod) {
    final PsiMethod newGetter =
      PropertyUtil.findPropertyGetter(containingClass, newName, field.hasModifierProperty(PsiModifier.STATIC), true);
    if (newGetter != null && !(newGetter instanceof GrAccessorMethod)) {
      conflicts.putValue(newGetter, GroovyRefactoringBundle
        .message("implicit.getter.will.by.overriden.by.method", field.getName(), newGetter.getName()));
    }
  }
  final PsiMethod setter = GroovyPropertyUtils.findSetterForField(field);
  if (setter instanceof GrAccessorMethod) {
    final PsiMethod newSetter =
      PropertyUtil.findPropertySetter(containingClass, newName, field.hasModifierProperty(PsiModifier.STATIC), true);
    if (newSetter != null && !(newSetter instanceof GrAccessorMethod)) {
      conflicts.putValue(newSetter, GroovyRefactoringBundle
        .message("implicit.setter.will.by.overriden.by.method", field.getName(), newSetter.getName()));
    }
  }
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
public Collection<PsiElement> getAdditionalElementsToDelete(final PsiElement element,
                                                            final Collection<PsiElement> allElementsToDelete,
                                                            final boolean askUser) {
  if (element instanceof PsiField) {
    PsiField field = (PsiField)element;
    final Project project = element.getProject();
    String propertyName = JavaCodeStyleManager.getInstance(project).variableNameToPropertyName(field.getName(), VariableKind.FIELD);

    PsiClass aClass = field.getContainingClass();
    if (aClass != null) {
      boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC);
      PsiMethod[] getters = GetterSetterPrototypeProvider.findGetters(aClass, propertyName, isStatic);
      if (getters != null) {
        final List<PsiMethod> validGetters = new ArrayList<PsiMethod>(1);
        for (PsiMethod getter : getters) {
          if (!allElementsToDelete.contains(getter) && (getter != null && getter.isPhysical())) {
            validGetters.add(getter);
          }
        }
        getters = validGetters.isEmpty() ? null : validGetters.toArray(new PsiMethod[validGetters.size()]);
      }

      PsiMethod setter = PropertyUtil.findPropertySetter(aClass, propertyName, isStatic, false);
      if (allElementsToDelete.contains(setter) || setter != null && !setter.isPhysical()) setter = null;
      if (askUser && (getters != null || setter != null)) {
        final String message =
          RefactoringMessageUtil.getGetterSetterMessage(field.getName(), RefactoringBundle.message("delete.title"), getters != null ? getters[0] : null, setter);
        if (!ApplicationManager.getApplication().isUnitTestMode() && Messages.showYesNoDialog(project, message, RefactoringBundle.message("safe.delete.title"), Messages.getQuestionIcon()) != 0) {
          getters = null;
          setter = null;
        }
      }
      List<PsiElement> elements = new ArrayList<PsiElement>();
      if (setter != null) elements.add(setter);
      if (getters != null) Collections.addAll(elements, getters);
      return elements;
    }
  }
  return null;
}
 

import com.intellij.psi.util.PropertyUtil; //导入方法依赖的package包/类
public Object getData(final String dataId) {
  if(getClass().getName().equals(dataId)){
    return this;
  }
  else if(LangDataKeys.PSI_ELEMENT.is(dataId)){
    final IntrospectedProperty introspectedProperty = getSelectedIntrospectedProperty();
    if(introspectedProperty == null){
      return null;
    }
    final PsiClass aClass = getComponentClass();
    if(aClass == null){
      return null;
    }

    final PsiMethod getter = PropertyUtil.findPropertyGetter(aClass, introspectedProperty.getName(), false, true);
    if(getter != null){
      return getter;
    }

    return PropertyUtil.findPropertySetter(aClass, introspectedProperty.getName(), false, true);
  }
  else if (LangDataKeys.PSI_FILE.is(dataId) && myEditor != null) {
    return PsiManager.getInstance(myEditor.getProject()).findFile(myEditor.getFile());
  }
  else if (GuiEditor.DATA_KEY.is(dataId)) {
    return myEditor;
  }
  else if (PlatformDataKeys.FILE_EDITOR.is(dataId)) {
    return UIDesignerToolWindowManager.getInstance(myProject).getActiveFormFileEditor();
  }
  else if (PlatformDataKeys.HELP_ID.is(dataId)) {
    return ourHelpID;
  }
  else {
    return null;
  }
}