@Override public boolean visitField(UField field) {
  PsiModifierList modifierList = field.getModifierList();
  if (modifierList == null || modifierList.hasModifierProperty(PsiModifier.TRANSIENT)) {
    return false;
  }

  if (!isInJob(field)) {
    return false;
  }

  if (hasAnnotation(modifierList, JAVAX_INJECT)) {
    context.report(ISSUE, context.getLocation(field), LINT_ERROR_MESSAGE);
  }

  return super.visitField(field);
}
 

private static PsiMethod[] findSpecMethods(PsiMethod componentMethod, Project project) {
  if (!componentMethod.getModifierList().hasModifierProperty(PsiModifier.STATIC)) {
    return PsiMethod.EMPTY_ARRAY;
  }

  final PsiClass containingCls =
      (PsiClass) PsiTreeUtil.findFirstParent(componentMethod, PsiClass.class::isInstance);
  if (containingCls == null) return PsiMethod.EMPTY_ARRAY;

  if (!LithoPluginUtils.isGeneratedClass(containingCls)) return PsiMethod.EMPTY_ARRAY;

  // For Unit testing we don't care about package
  final String containingClsName =
      ApplicationManager.getApplication().isUnitTestMode()
          ? containingCls.getName()
          : containingCls.getQualifiedName();
  final PsiClass specCls =
      PsiSearchUtils.findOriginalClass(
          project, LithoPluginUtils.getLithoComponentSpecNameFromComponent(containingClsName));
  if (specCls == null) return PsiMethod.EMPTY_ARRAY;

  return specCls.findMethodsByName(componentMethod.getName(), true);
}
 

@Nullable
private static TestContext fromSelectedMethods(List<PsiMethod> selectedMethods) {
  // Sort so multiple configurations created with different selection orders are the same.
  selectedMethods.sort(Comparator.comparing(PsiMethod::getName));
  PsiMethod firstMethod = selectedMethods.get(0);
  PsiClass containingClass = firstMethod.getContainingClass();
  if (containingClass == null || containingClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
    return null;
  }
  for (PsiMethod method : selectedMethods) {
    if (!containingClass.equals(method.getContainingClass())) {
      return null;
    }
  }
  return fromClassAndMethods(containingClass, selectedMethods);
}
 

public void testUtilityClassModifiersInnerClass() {
  PsiFile file = myFixture.configureByFile(getTestName(false) + ".java");
  PsiClass innerClass = PsiTreeUtil.getParentOfType(file.findElementAt(myFixture.getCaretOffset()), PsiClass.class);

  assertNotNull(innerClass);
  assertNotNull(innerClass.getModifierList());

  PsiElement parent = innerClass.getParent();

  assertNotNull(parent);
  assertTrue(parent instanceof PsiClass);

  PsiClass parentClass = (PsiClass) parent;

  assertNotNull(parentClass.getModifierList());
  assertTrue("@UtilityClass should make parent class final", ((PsiClass) innerClass.getParent()).getModifierList().hasModifierProperty(PsiModifier.FINAL));
  assertTrue("@UtilityClass should make inner class static", innerClass.getModifierList().hasModifierProperty(PsiModifier.STATIC));
}
 

public void testUtilityClassModifiersField() {
  PsiFile file = myFixture.configureByFile(getTestName(false) + ".java");
  PsiField field = PsiTreeUtil.getParentOfType(file.findElementAt(myFixture.getCaretOffset()), PsiField.class);

  assertNotNull(field);
  assertNotNull(field.getModifierList());

  PsiElement parent = field.getParent();

  assertNotNull(parent);
  assertTrue(parent instanceof PsiClass);

  PsiClass parentClass = (PsiClass) parent;

  assertNotNull(parentClass.getModifierList());
  assertTrue("@UtilityClass should make parent class final", parentClass.getModifierList().hasModifierProperty(PsiModifier.FINAL));
  assertTrue("@UtilityClass should make field static", field.getModifierList().hasModifierProperty(PsiModifier.STATIC));
}
 

@Override
public void transformModifiers(@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) {
  final PsiElement parent = modifierList.getParent();

  // FINAL
  if (parent instanceof PsiClass) {
    PsiClass psiClass = (PsiClass) parent;
    if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, UtilityClass.class)) {
      modifiers.add(PsiModifier.FINAL);
    }
  }

  // STATIC
  if (isElementFieldOrMethodOrInnerClass(parent)) {
    modifiers.add(PsiModifier.STATIC);
  }
}
 

/**
 * @param file   psi file
 * @param editor editor
 * @return psiClass if class is static or top level. Otherwise returns {@code null}
 */
@Nullable
public static PsiClass getStaticOrTopLevelClass(PsiFile file, Editor editor) {
    final int offset = editor.getCaretModel().getOffset();
    final PsiElement element = file.findElementAt(offset);
    if (element == null) {
        return null;
    }

    PsiClass topLevelClass = PsiUtil.getTopLevelClass(element);
    PsiClass psiClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
    if (psiClass != null && (psiClass.hasModifierProperty(PsiModifier.STATIC) ||
            psiClass.getManager().areElementsEquivalent(psiClass, topLevelClass)))
        return psiClass;
    else
        return null;
}
 

public void testUtilityClassModifiersMethod() {
  PsiFile file = myFixture.configureByFile(getTestName(false) + ".java");
  PsiMethod method = PsiTreeUtil.getParentOfType(file.findElementAt(myFixture.getCaretOffset()), PsiMethod.class);

  assertNotNull(method);
  assertNotNull(method.getModifierList());

  PsiElement parent = method.getParent();

  assertNotNull(parent);
  assertTrue(parent instanceof PsiClass);

  PsiClass parentClass = (PsiClass) parent;

  assertNotNull(parentClass.getModifierList());
  assertTrue("@UtilityClass should make parent class final", ((PsiClass) method.getParent()).getModifierList().hasModifierProperty(PsiModifier.FINAL));
  assertTrue("@UtilityClass should make method static", method.getModifierList().hasModifierProperty(PsiModifier.STATIC));
}
 

@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;
}
 

public Collection<PsiField> renderBuilderFields(@NotNull BuilderInfo info) {
  final PsiType keyType = getKeyType(info.getManager(), info.getFieldType());
  final PsiType builderFieldKeyType = getBuilderFieldType(keyType, info.getProject());

  final PsiType valueType = getValueType(info.getManager(), info.getFieldType());
  final PsiType builderFieldValueType = getBuilderFieldType(valueType, info.getProject());

  return Arrays.asList(
    new LombokLightFieldBuilder(info.getManager(), info.getFieldName() + LOMBOK_KEY, builderFieldKeyType)
      .withContainingClass(info.getBuilderClass())
      .withModifier(PsiModifier.PRIVATE)
      .withNavigationElement(info.getVariable()),
    new LombokLightFieldBuilder(info.getManager(), info.getFieldName() + LOMBOK_VALUE, builderFieldValueType)
      .withContainingClass(info.getBuilderClass())
      .withModifier(PsiModifier.PRIVATE)
      .withNavigationElement(info.getVariable()));
}
 

public void testValModifiersEditing() {
  PsiFile file = myFixture.configureByText("a.java", "import lombok.val;\nclass Foo { {val o = <caret>;} }");
  PsiLocalVariable var = PsiTreeUtil.getParentOfType(file.findElementAt(myFixture.getCaretOffset()), PsiLocalVariable.class);
  assertNotNull(var);

  PsiType type1 = var.getType();
  assertNotNull(type1);
  assertEquals("lombok.val", type1.getCanonicalText(false));

  myFixture.type('1');
  PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
  assertTrue(var.isValid());

  assertNotNull(var.getModifierList());
  assertTrue("val should make variable final", var.getModifierList().hasModifierProperty(PsiModifier.FINAL));
}
 

private static List<Modifier> extractModifiersInternal(PsiModifierList modifierList) {
  List<Modifier> modifiers = new ArrayList<>();

  PsiElement[] children = modifierList.getChildren();
  for (PsiElement child : children) {
    if (child instanceof PsiModifier || child instanceof PsiKeyword) {
      modifiers.add(psiModifierToModifier(child));
    }
  }
  return modifiers;
}
 

private static Modifier psiModifierToModifier(PsiElement psiModifier) {
  switch (psiModifier.getText()) {
    case PsiModifier.ABSTRACT:
      return Modifier.ABSTRACT;
    case PsiModifier.FINAL:
      return Modifier.FINAL;
    case PsiModifier.NATIVE:
      return Modifier.NATIVE;
    case PsiModifier.PRIVATE:
      return Modifier.PRIVATE;
    case PsiModifier.PROTECTED:
      return Modifier.PROTECTED;
    case PsiModifier.PUBLIC:
      return Modifier.PUBLIC;
    case PsiModifier.STATIC:
      return Modifier.STATIC;
    case PsiModifier.STRICTFP:
      return Modifier.STRICTFP;
    case PsiModifier.SYNCHRONIZED:
      return Modifier.SYNCHRONIZED;
    case PsiModifier.TRANSIENT:
      return Modifier.TRANSIENT;
    case PsiModifier.VOLATILE:
      return Modifier.VOLATILE;
    default:
      // TODO better error message, ideally w/ line number
      throw new ComponentsProcessingException(
          "Unexpected Modifier, modifier is: " + psiModifier.getText());
  }
}
 

private void markLeakSuspects(PsiElement element, PsiElement lambdaBody, @NonNull final JavaContext context) {
    if (element instanceof PsiReferenceExpression) {
        PsiReferenceExpression ref = (PsiReferenceExpression) element;

        if (ref.getQualifierExpression() == null) {

            PsiElement res = ref.resolve();
            if (!(res instanceof PsiParameter)) {
                if (!(res instanceof PsiClass)) {

                    boolean error = false;
                    if (res instanceof PsiLocalVariable) {
                        PsiLocalVariable lVar = (PsiLocalVariable) res;
                        if (!isParent(lambdaBody, lVar.getParent())) {
                            error = true;
                        }
                    }

                    if (res instanceof PsiField) {
                        PsiField field = (PsiField) res;
                        final PsiModifierList modifierList = field.getModifierList();
                        if (modifierList == null) {
                            error = true;
                        } else if (!modifierList.hasExplicitModifier(PsiModifier.STATIC)) {
                            error = true;
                        }
                    }

                    if (error) {
                        context.report(ISSUE, element, context.getNameLocation(element), "Possible leak");
                    }
                }
            }
        }
    }

    for (PsiElement psiElement : element.getChildren()) {
        markLeakSuspects(psiElement, lambdaBody, context);
    }
}
 

/**
 * Return all beans which is not private and abstract;
 * @param methods - List of methods to filter
 * @return - List of filtered methods
 */
public Collection<PsiMethod> getBeanAccessibleMethods(Collection<PsiMethod> methods) {
    return methods.stream()
        .filter(method -> !isMatchOneOfModifierType(method, PsiModifier.PRIVATE, PsiModifier.ABSTRACT))
        .filter(method -> !method.isConstructor())
        .collect(Collectors.toList());
}
 

@Override
public boolean isImplicitUsage(PsiElement element) {
  if (!(element instanceof PsiMethod)) {
    return false;
  }
  PsiMethod method = (PsiMethod) element;
  if (method.hasModifierProperty(PsiModifier.PRIVATE)) {
    return false;
  }
  PsiModifierList modifiers = method.getModifierList();
  return IMPLICIT_METHOD_USAGE_ANNOTATIONS
      .stream()
      .anyMatch(s -> modifiers.findAnnotation(s) != null);
}
 

/** Returns true if the method is called in generated code. */
static boolean isImplicitUsageMethod(PsiElement element) {
  if (!(element instanceof PsiMethod)) {
    return false;
  }
  PsiMethod method = (PsiMethod) element;
  if (method.hasModifierProperty(PsiModifier.PRIVATE)) {
    return false;
  }
  PsiModifierList modifiers = method.getModifierList();
  return IMPLICIT_METHOD_USAGE_ANNOTATIONS
      .stream()
      .anyMatch(s -> modifiers.findAnnotation(s) != null);
}
 

static boolean isAutoFactoryClass(PsiElement element) {
  PsiClass psiClass = getPsiClass(element);
  if (psiClass == null || !psiClass.hasModifierProperty(PsiModifier.PUBLIC)) {
    return false;
  }
  PsiModifierList modifiers = psiClass.getModifierList();
  return modifiers != null && modifiers.findAnnotation(AUTO_FACTORY_ANNOTATION) != null;
}
 

private static PsiClass getNonAbstractTestClass(PsiElement element) {
  PsiClass testClass = ProducerUtils.getTestClass(element);
  if (testClass == null || testClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
    return null;
  }
  return testClass;
}
 

static void chooseSubclass(
    ConfigurationContext context,
    PsiClass testClass,
    Consumer<PsiClass> callbackOnClassSelection) {
  List<PsiClass> classes = findTestSubclasses(testClass);
  if (!testClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
    classes.add(testClass);
  }
  if (classes.isEmpty()) {
    return;
  }
  if (classes.size() == 1) {
    callbackOnClassSelection.accept(classes.get(0));
    return;
  }
  PsiClassListCellRenderer renderer = new PsiClassListCellRenderer();
  classes.sort(renderer.getComparator());
  JBList<PsiClass> list = new JBList<>(classes);
  list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  list.setCellRenderer(renderer);
  JBPopupFactory.getInstance()
      .createListPopupBuilder(list)
      .setTitle("Choose test class to run")
      .setMovable(false)
      .setResizable(false)
      .setRequestFocus(true)
      .setCancelOnWindowDeactivation(false)
      .setItemChoosenCallback(
          () -> callbackOnClassSelection.accept((PsiClass) list.getSelectedValue()))
      .createPopup()
      .showInBestPositionFor(context.getDataContext());
}
 

@Nullable
@Override
public RunConfigurationContext getTestContext(ConfigurationContext context) {
  final List<PsiMethod> selectedMethods = TestMethodSelectionUtil.getSelectedMethods(context);
  if (selectedMethods != null && !selectedMethods.isEmpty()) {
    return fromSelectedMethods(selectedMethods);
  }
  // otherwise look for a single selected class
  PsiClass testClass = getSelectedTestClass(context);
  if (testClass == null || testClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
    return null;
  }
  return fromClass(testClass);
}
 

private static boolean canHaveSuperMethod(PsiMethod method, boolean allowStaticMethod) {
  // Private really means protected in Haxe, so this version skips the private test.
  if (null == method || method.isConstructor()) return false;
  if (!allowStaticMethod && method.hasModifierProperty(PsiModifier.STATIC)) return false;
  PsiClass parentClass = method.getContainingClass();
  return parentClass != null;
}
 

private static boolean cannotBeOverriden(final PsiMethod method) {
  // In Haxe, private really means what protected means in Java.
  // There is no final keyword, either.
  final PsiClass parentClass = method.getContainingClass();
  return parentClass == null
         || method.isConstructor()
         || method.hasModifierProperty(PsiModifier.STATIC)
         || parentClass instanceof PsiAnonymousClass;
}
 

@Override
public void transformModifiers(@NotNull PsiModifierList modifierList, @NotNull final Set<String> modifiers) {
  if (modifiers.contains(PsiModifier.STATIC)) {
    return; // skip static fields
  }

  final PsiModifierListOwner parentElement = PsiTreeUtil.getParentOfType(modifierList, PsiModifierListOwner.class, false);
  if (null != parentElement) {

    // FINAL
    if (!PsiAnnotationSearchUtil.isAnnotatedWith(parentElement, lombok.experimental.NonFinal.class)) {
      modifiers.add(PsiModifier.FINAL);
    }

    // PRIVATE
    if (modifierList.getParent() instanceof PsiField &&
      // Visibility is only changed for package private fields
      hasPackagePrivateModifier(modifierList) &&
      // except they are annotated with @PackagePrivate
      !PsiAnnotationSearchUtil.isAnnotatedWith(parentElement, lombok.experimental.PackagePrivate.class)) {
      modifiers.add(PsiModifier.PRIVATE);

      // IDEA _right now_ checks if other modifiers are set, and ignores PACKAGE_LOCAL but may as well clean it up
      modifiers.remove(PsiModifier.PACKAGE_LOCAL);
    }
  }
}
 

@NotNull
Collection<PsiField> filterFields(@NotNull PsiClass psiClass, PsiAnnotation psiAnnotation) {
  final Collection<PsiField> psiFields = new ArrayList<>();

  final boolean onlyExplicitlyIncluded = PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "onlyExplicitlyIncluded", false);

  for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) {
    boolean useField = true;
    PsiModifierList modifierList = psiField.getModifierList();
    if (null != modifierList) {

      //Skip static fields.
      useField = !modifierList.hasModifierProperty(PsiModifier.STATIC);
      //Skip transient fields
      useField &= !modifierList.hasModifierProperty(PsiModifier.TRANSIENT);
    }
    //Skip fields that start with $
    useField &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER);
    //Skip fields annotated with @FieldNameConstants.Exclude
    useField &= !PsiAnnotationSearchUtil.isAnnotatedWith(psiField, FIELD_NAME_CONSTANTS_EXCLUDE);

    if (onlyExplicitlyIncluded) {
      //Only use fields annotated with @FieldNameConstants.Include, Include annotation overrides other rules
      useField = PsiAnnotationSearchUtil.isAnnotatedWith(psiField, FIELD_NAME_CONSTANTS_INCLUDE);
    }

    if (useField) {
      psiFields.add(psiField);
    }
  }
  return psiFields;
}
 

@Override
protected void generatePsiElements(@NotNull final PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) {

  LombokLightMethodBuilder constructorBuilder = new LombokLightMethodBuilder(psiClass.getManager(), psiClass.getName())
    .withConstructor(true)
    .withContainingClass(psiClass)
    .withNavigationElement(psiAnnotation)
    .withModifier(PsiModifier.PRIVATE);

  String methodBody = String.format("throw new %s(%s);", "java.lang.UnsupportedOperationException", "\"This is a utility class and cannot be instantiated\"");

  constructorBuilder.withBody(PsiMethodUtil.createCodeBlockFromText(methodBody, constructorBuilder));
  target.add(constructorBuilder);
}
 

private boolean validateFinalModifier(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemBuilder builder) {
  boolean result = true;
  if (psiField.hasModifierProperty(PsiModifier.FINAL) && null != LombokProcessorUtil.getMethodModifier(psiAnnotation)) {
    builder.addWarning("Not generating setter for this field: Setters cannot be generated for final fields.",
      PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, false, false));
    result = false;
  }
  return result;
}
 

private PsiType getReturnType(@NotNull PsiField psiField) {
  PsiType result = PsiType.VOID;
  if (!psiField.hasModifierProperty(PsiModifier.STATIC) && AccessorsInfo.build(psiField).isChain()) {
    final PsiClass fieldClass = psiField.getContainingClass();
    if (null != fieldClass) {
      result = PsiClassUtil.getTypeWithGenerics(fieldClass);
    }
  }
  return result;
}
 

@Override
protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemBuilder builder) {
  boolean result;

  final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation);
  result = null != methodVisibility;

  final boolean lazy = isLazyGetter(psiAnnotation);
  if (null == methodVisibility && lazy) {
    builder.addWarning("'lazy' does not work with AccessLevel.NONE.");
  }

  if (result && lazy) {
    if (!psiField.hasModifierProperty(PsiModifier.FINAL) || !psiField.hasModifierProperty(PsiModifier.PRIVATE)) {
      builder.addError("'lazy' requires the field to be private and final",
        PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.PRIVATE, true, false),
        PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, true, false));
      result = false;
    }
    if (null == psiField.getInitializer()) {
      builder.addError("'lazy' requires field initialization.");
      result = false;
    }
  }

  if (result) {
    result = validateExistingMethods(psiField, builder);
  }

  if (result) {
    result = validateAccessorPrefix(psiField, builder);
  }

  return result;
}
 

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