private boolean validateExistingMethods(@NotNull PsiField psiField, @NotNull ProblemBuilder builder) {
  boolean result = true;
  final PsiClass psiClass = psiField.getContainingClass();
  if (null != psiClass) {
    final Collection<PsiMethod> classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass);
    filterToleratedElements(classMethods);

    final boolean isBoolean = PsiType.BOOLEAN.equals(psiField.getType());
    final Collection<String> methodNames = getAllSetterNames(psiField, isBoolean);

    for (String methodName : methodNames) {
      if (PsiMethodUtil.hasSimilarMethod(classMethods, methodName, 1)) {
        final String setterMethodName = getSetterName(psiField, isBoolean);

        builder.addWarning("Not generated '%s'(): A method with similar name '%s' already exists", setterMethodName, methodName);
        result = false;
      }
    }
  }
  return result;
}
 

@Override public boolean shouldShow(UsageTarget target, Usage usage) {
  PsiElement element = ((UsageInfo2UsageAdapter) usage).getElement();

  PsiField field = PsiConsultantImpl.findField(element);
  if (field != null //
      && PsiConsultantImpl.hasAnnotation(field, CLASS_INJECT) //
      && PsiConsultantImpl.hasQuailifierAnnotations(field, qualifierAnnotations)
      && PsiConsultantImpl.hasTypeParameters(field, typeParameters)) {
    return true;
  }

  PsiMethod method = PsiConsultantImpl.findMethod(element);
  if (method != null && (PsiConsultantImpl.hasAnnotation(method, CLASS_INJECT)
          || PsiConsultantImpl.hasAnnotation(method, CLASS_PROVIDES))) {
    for (PsiParameter parameter : method.getParameterList().getParameters()) {
      PsiClass parameterClass = PsiConsultantImpl.checkForLazyOrProvider(parameter);
      if (parameterClass.equals(returnType) && PsiConsultantImpl.hasQuailifierAnnotations(
          parameter, qualifierAnnotations)
          && PsiConsultantImpl.hasTypeParameters(parameter, typeParameters)) {
        return true;
      }
    }
  }

  return false;
}
 

public static String getConfigFieldType(final PsiField configField) {
	final PsiAnnotation configAnnotation = extractConfigAnnotation(configField);

	if (configAnnotation == null) {
		return null;
	}

	if (isJsonConfigAnnotation(configAnnotation)) {
		final PsiImmediateClassType jsonType = getAttributeValue(configAnnotation, ATTRIBUTE_TYPE);
		return jsonType.resolve()
		               .getQualifiedName();
	}
	else if (isEnumConfigAnnotation(configAnnotation)) {
		return getEnumConfigImplClass(configAnnotation);
	}
	else if (isColorConfigAnnotation(configAnnotation)) {
		return getColorIntClass();
	}
	else if (isConfigGroupAnnotation(configAnnotation)) {
		return getConfigGroupImplClass(configField);
	}
	else {
		final PsiClass annotationClass = ElementUtils.getAnnotationDeclarationClass(configAnnotation);
		return annotationClass != null ? ElementUtils.getQualifiedName(getDefaultValueMethod(annotationClass).getReturnType()) : null;
	}
}
 

@NotNull
public PsiMethod createGetterMethod(@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull String methodModifier) {
  final String methodName = LombokUtils.getGetterName(psiField);

  LombokLightMethodBuilder methodBuilder = new LombokLightMethodBuilder(psiField.getManager(), methodName)
    .withMethodReturnType(psiField.getType())
    .withContainingClass(psiClass)
    .withNavigationElement(psiField);
  if (StringUtil.isNotEmpty(methodModifier)) {
    methodBuilder.withModifier(methodModifier);
  }
  boolean isStatic = psiField.hasModifierProperty(PsiModifier.STATIC);
  if (isStatic) {
    methodBuilder.withModifier(PsiModifier.STATIC);
  }

  final String blockText = String.format("return %s.%s;", isStatic ? psiClass.getName() : "this", psiField.getName());
  methodBuilder.withBody(PsiMethodUtil.createCodeBlockFromText(blockText, methodBuilder));

  PsiModifierList modifierList = methodBuilder.getModifierList();
  copyAnnotations(psiField, modifierList,
    LombokUtils.NON_NULL_PATTERN, LombokUtils.NULLABLE_PATTERN, LombokUtils.DEPRECATED_PATTERN);
  addOnXAnnotations(PsiAnnotationSearchUtil.findAnnotation(psiField, Getter.class), modifierList, "onMethod");
  return methodBuilder;
}
 

@Override
protected void addNullableValue(PsiField field, StringBuilder sb, String defaultName) {
    boolean add = PropertiesComponent.getInstance().getBoolean(Constant.VALUE_NULL, false);
    if (!add) {
        sb.append(field.getName()).append("?.also{\n");
        sb.append(mFieldName).append(".addFormDataPart(");
        if (defaultName == null) {
            sb.append('"').append(field.getName()).append('"');
        } else {
            sb.append(defaultName);
        }
        sb.append(", ").append(toString(field, false, "it")).append(")\n}\n");
    } else {
        sb.append(mFieldName).append(".addFormDataPart(");
        if (defaultName == null) {
            sb.append('"').append(field.getName()).append('"');
        } else {
            sb.append(defaultName);
        }
        sb.append(", ").append(toString(field, true, null)).append(" ?: \"\" )\n");
    }
}
 

public static boolean isInitializedInConstructors(@NotNull PsiElement element) {
  if (!(element instanceof PsiIdentifier)) {
    return false;
  }
  PsiElement parent = element.getParent();
  if (!(parent instanceof PsiReferenceExpression)) {
    return false;
  }
  PsiElement qualifier = ((PsiReferenceExpression) parent).getQualifier();
  if (qualifier == null) {
    return false;
  }
  PsiReference reference = qualifier.getReference();
  if (reference == null) {
    return false;
  }
  PsiElement field = reference.resolve();
  if (!(field instanceof PsiField)) {
    return false;
  }
  PsiClass containingClass = ((PsiField) field).getContainingClass();
  if (containingClass == null) {
    return false;
  }
  return isInitializedInConstructors((PsiField) field, containingClass);
}
 

private void visitPsiFields(final PsiField psiField) {
    if (!ClassUtils.isPrimitive(psiField.getType())) {
        String type = removeSpecialSymbols(psiField.getType().getCanonicalText());
        if (psiField.getInitializer() != null) {
            PsiExpression psiExpression = psiField.getInitializer();
            if (psiExpression != null) {
                PsiType psiType = psiExpression.getType();
                if (psiType != null && !ClassUtils.isPrimitive(psiType)) {
                    String psiFieldInitializer =
                            removeSpecialSymbols(psiType.getCanonicalText());
                    addInMap(psiFieldInitializer, emptySet);
                }
            }
        }
        addInMap(type, emptySet);
    }
}
 

private boolean validateExistingMethods(@NotNull PsiField psiField, @NotNull ProblemBuilder builder) {
  boolean result = true;
  final PsiClass psiClass = psiField.getContainingClass();
  if (null != psiClass) {
    final boolean isBoolean = PsiType.BOOLEAN.equals(psiField.getType());
    final AccessorsInfo accessorsInfo = AccessorsInfo.build(psiField);
    final Collection<String> methodNames = LombokUtils.toAllGetterNames(accessorsInfo, psiField.getName(), isBoolean);
    final Collection<PsiMethod> classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass);
    filterToleratedElements(classMethods);

    for (String methodName : methodNames) {
      if (PsiMethodUtil.hasSimilarMethod(classMethods, methodName, 0)) {
        final String setterMethodName = LombokUtils.getGetterName(psiField);

        builder.addWarning("Not generated '%s'(): A method with similar name '%s' already exists", setterMethodName, methodName);
        result = false;
      }
    }
  }
  return result;
}
 

@Override
public final void visitElement(final PsiElement element) {
    super.visitElement(element);
    if (startOffset <= element.getTextOffset() && element.getTextOffset() <= endOffset) {
        if (element.getNode().getElementType().equals(JavaElementType.FIELD)) {
            visitPsiFields((PsiField) element);
        } else if (element.getNode().getElementType().
                equals(JavaElementType.DECLARATION_STATEMENT)) {
            visitPsiDeclarationStatement((PsiDeclarationStatement) element);
        } else if (element.getNode().getElementType().equals(JavaElementType.CATCH_SECTION)) {
            visitPsiCatchSection((PsiCatchSection) element);
        } else if (element.getNode().getElementType().
                equals(JavaElementType.RETURN_STATEMENT)) {
            visitPsiReturnStatement((PsiReturnStatement) element);
        } else {
            visitExpression(element);
        }
    }
}
 

@Override
protected void addNullableValue(PsiField field, StringBuilder sb, String defaultName) {
    boolean add = PropertiesComponent.getInstance().getBoolean(Constant.VALUE_NULL, false);
    if (!add) {
        sb.append(field.getName()).append("?.also{\n");
        sb.append(mFieldName).append(".add(").append(getValueType()).append(".createFormData(");
        if (defaultName == null) {
            sb.append('"').append(field.getName()).append('"');
        } else {
            sb.append(defaultName);
        }
        sb.append(", ").append(toString(field, false, "it")).append("))\n}\n");
    } else {
        sb.append(mFieldName).append(".add(").append(getValueType()).append(".createFormData(");
        if (defaultName == null) {
            sb.append('"').append(field.getName()).append('"');
        } else {
            sb.append(defaultName);
        }
        sb.append(", ").append(toString(field, true, null)).append(" ?: \"\"))\n");
    }
}
 

private String buildAttributeNameString(boolean doNotUseGetters, @NotNull PsiField classField, @NotNull PsiClass psiClass) {
  final String fieldName = classField.getName();
  if (doNotUseGetters) {
    return fieldName;
  } else {
    final String getterName = LombokUtils.getGetterName(classField);

    final boolean hasGetter;
    @SuppressWarnings("unchecked") final boolean annotatedWith = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Data.class, Value.class, Getter.class);
    if (annotatedWith) {
      final PsiAnnotation getterLombokAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, Getter.class);
      hasGetter = null == getterLombokAnnotation || null != LombokProcessorUtil.getMethodModifier(getterLombokAnnotation);
    } else {
      hasGetter = PsiMethodUtil.hasMethodByName(PsiClassUtil.collectClassMethodsIntern(psiClass), getterName);
    }

    return hasGetter ? getterName + "()" : fieldName;
  }
}
 

@Override
protected void addNullableValue(PsiField field, StringBuilder sb, String defaultName) {
    boolean add = PropertiesComponent.getInstance().getBoolean(Constant.VALUE_NULL, false);
    if (!add) {
        sb.append(field.getName()).append("?.also{\n");
        sb.append(mFieldName).append("[");
        if (defaultName == null) {
            sb.append('"').append(field.getName()).append('"');
        } else {
            sb.append(defaultName);
        }
        sb.append("] = ").append(toString(field, false, "it")).append("\n}\n");
    } else {
        sb.append(mFieldName).append("[");
        if (defaultName == null) {
            sb.append('"').append(field.getName()).append('"');
        } else {
            sb.append(defaultName);
        }
        sb.append("] = ").append(toString(field, true, null)).append("?: \"\"\n");
    }
}
 

@Override
protected void buildMethodBody(PsiClass psiClass, PsiField[] fields, boolean needAll, StringBuilder sb) {
    for (PsiField field : fields) {
        PsiElement older = null;
        if (field instanceof KtLightField) {
            older = ((KtLightField) field).getKotlinOrigin();
        }
        if (!findIgnore(older == null ? field : older)) {
            String defaultName  = getParamName(older == null ? field : older);
            if (isNullable(field)) {
                addNullableValue(field, sb, defaultName);
            } else {
                sb.append(mFieldName).append(".put(");
                if (defaultName == null ) {
                    sb.append('"').append(field.getName()).append('"');
                } else {
                    sb.append(defaultName);
                }
                sb.append(", ").append(toString(field)).append(");");
            }

        }
    }
}
 

public Collection<PsiField> renderBuilderFields(@NotNull BuilderInfo info) {
  final PsiType builderFieldKeyType = getBuilderFieldType(info.getFieldType(), info.getProject());
  return Collections.singleton(
    new LombokLightFieldBuilder(info.getManager(), info.getFieldName(), builderFieldKeyType)
      .withContainingClass(info.getBuilderClass())
      .withModifier(PsiModifier.PRIVATE)
      .withNavigationElement(info.getVariable()));
}
 

@NotNull
@Override
public Collection<LombokProblem> verifyAnnotation(@NotNull PsiAnnotation psiAnnotation) {
  Collection<LombokProblem> result = Collections.emptyList();
  // check first for fields, methods and filter it out, because PsiClass is parent of all annotations and will match other parents too
  @SuppressWarnings("unchecked")
  PsiElement psiElement = PsiTreeUtil.getParentOfType(psiAnnotation, PsiField.class, PsiMethod.class, PsiClass.class);
  if (psiElement instanceof PsiClass) {
    ProblemNewBuilder problemNewBuilder = new ProblemNewBuilder();
    validate(psiAnnotation, (PsiClass) psiElement, problemNewBuilder);
    result = problemNewBuilder.getProblems();
  }

  return result;
}
 

/**
 * 默认的生成
 *
 * @param psiField 当前属性
 * @return {@link java.lang.String}
 */
private String defaultGenerate(PsiField psiField) {
    if (BooleanUtils.isTrue(config.getSimpleFieldDoc())) {
        return genSimpleDoc(psiField.getName());
    } else {
        return genNormalDoc(psiField, psiField.getName());
    }
}
 

@Override
public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) {
  final PsiClass containingClass = psiField.getContainingClass();
  if (null != containingClass) {
    if (PsiClassUtil.getNames(getRequiredFields(containingClass)).contains(psiField.getName())) {
      return LombokPsiElementUsage.WRITE;
    }
  }
  return LombokPsiElementUsage.NONE;
}
 

@Override
public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) {
  final PsiClass containingClass = psiField.getContainingClass();
  if (null != containingClass) {
    if (PsiClassUtil.getNames(filterFields(containingClass, psiAnnotation)).contains(psiField.getName())) {
      return LombokPsiElementUsage.USAGE;
    }
  }
  return LombokPsiElementUsage.NONE;
}
 

public static PsiClass checkForLazyOrProvider(PsiField psiField) {
  PsiClass wrapperClass = PsiConsultantImpl.getClass(psiField);

  PsiType psiFieldType = psiField.getType();
  if (!(psiFieldType instanceof PsiClassType)) {
    return wrapperClass;
  }

  return getPsiClass(wrapperClass, psiFieldType);
}
 

private boolean containsConfig(String name, Collection<PsiField> configs) {
	for (PsiField config : configs) {
		if (config.getName()
		          .equals(name)) {
			return true;
		}
	}
	return false;
}
 

private void processClassMethods(PsiField refPsiField, SearchRequestCollector collector, PsiClass containingClass) {
  Arrays.stream(containingClass.getMethods())
    .filter(LombokLightMethodBuilder.class::isInstance)
    .filter(psiMethod -> psiMethod.getNavigationElement() == refPsiField)
    .forEach(psiMethod -> {
      collector.searchWord(psiMethod.getName(), psiMethod.getUseScope(), UsageSearchContext.IN_CODE, true, psiMethod);
    });
}
 

@Override
protected List<EncapsulatableClassMember> getEncapsulatableClassMembers(PsiClass psiClass) {
  final List<EncapsulatableClassMember> result = new ArrayList<>();
  for (PsiField field : psiClass.getFields()) {
    if (null != PropertyUtil.findPropertyGetter(psiClass, field.getName(), false, false)) {
      result.add(new PsiFieldMember(field));
    }
  }
  return result;
}
 

/**
 * Searching for the specific bean name and annotation to find it's {@link PsiClass}
 * @param beanName - Name of the bean to search for.
 * @param annotation - Type of bean annotation to filter on.
 * @param project - Project reference to narrow the search inside.
 * @return the {@link PsiClass} matching the bean name and annotation.
 */
public Optional<PsiClass> findBeanClassByName(String beanName, String annotation, Project project) {
    for (PsiClass psiClass : getClassesAnnotatedWith(project, annotation)) {
        final PsiAnnotation classAnnotation = psiClass.getAnnotation(annotation);
        PsiAnnotationMemberValue attribute = classAnnotation.findAttributeValue("value");
        if (attribute != null) {
            if (attribute instanceof PsiReferenceExpressionImpl) {
                //if the attribute value is field reference eg @bean(value = MyClass.BEAN_NAME)
                final PsiField psiField = (PsiField) attribute.getReference().resolve();
                String staticBeanName = StringUtils.stripDoubleQuotes(PsiTreeUtil.getChildOfAnyType(psiField, PsiLiteralExpression.class).getText());
                if (beanName.equals(staticBeanName)) {
                    return Optional.of(psiClass);
                }
            } else {
                final String value = attribute.getText();
                if (beanName.equals(StringUtils.stripDoubleQuotes(value))) {
                    return Optional.of(psiClass);
                }

            }
        } else {
            if (Introspector.decapitalize(psiClass.getName()).equalsIgnoreCase(StringUtils.stripDoubleQuotes(beanName))) {
                return Optional.of(psiClass);
            }
        }
    }

    return Optional.empty();
}
 

@Override
protected void processClass(@NotNull PsiClass psiClass) {
  final Map<PsiField, PsiMethod> fieldMethodMap = new HashMap<>();
  for (PsiField psiField : psiClass.getFields()) {
    PsiMethod propertySetter = PropertyUtil.findPropertySetter(psiClass, psiField.getName(), psiField.hasModifierProperty(PsiModifier.STATIC), false);

    if (null != propertySetter) {
      fieldMethodMap.put(psiField, propertySetter);
    }
  }

  processIntern(fieldMethodMap, psiClass, Setter.class);
}
 

@NotNull
public static PsiType getReferredPsiType(PsiElement psiElement) {
  if (psiElement instanceof PsiField) {
    return ((PsiField) psiElement).getType();
  } else if (psiElement instanceof PsiMethod) {
    return requireNonNull(((PsiMethod) psiElement).getReturnType());
  } else if (psiElement instanceof PsiClass) {
    return getClassType((PsiClass) psiElement);
  }
  throw new RuntimeException(
      "Method supports psiElement of type PsiField, PsiMethod & PsiClass only");
}
 

public static PsiAnnotation extractConfigAnnotation(PsiField field) {
	for (PsiAnnotation psiAnnotation : field.getAnnotations()) {
		if (isConfigAnnotation(psiAnnotation)) {
			return psiAnnotation;
		}
	}
	return null;
}
 

@NotNull
private Collection<PsiField> getConstructorFields(PsiClass containingClass, boolean forceConstructorWithJavaDefaults) {
  Collection<PsiField> params;
  if (forceConstructorWithJavaDefaults) {
    params = getRequiredFields(containingClass);
  } else {
    params = Collections.emptyList();
  }
  return params;
}
 

protected void addFieldsAnnotation(Collection<PsiAnnotation> result, @NotNull PsiClass psiClass, String... annotationFQNs) {
  for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) {
    PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, annotationFQNs);
    if (null != psiAnnotation) {
      result.add(psiAnnotation);
    }
  }
}
 

public static PsiAnnotation getRemoteValueAnnotation(PsiField field) {
	for (final PsiAnnotation psiAnnotation : field.getAnnotations()) {
		if (isRemoteValueAnnotation(psiAnnotation)) {
			return psiAnnotation;
		}
	}
	return null;
}
 

public void testValueModifiersStatic() {
  PsiFile file = myFixture.configureByFile(getTestName(false) + ".java");

  PsiField field = PsiTreeUtil.getParentOfType(file.findElementAt(myFixture.getCaretOffset()), PsiField.class);
  assertNotNull(field);
  assertNotNull(field.getModifierList());

  assertFalse("@Value should not make static variable final", field.getModifierList().hasModifierProperty(PsiModifier.FINAL));
  assertFalse("@Value should not make static variable private", field.getModifierList().hasModifierProperty(PsiModifier.PRIVATE));
}