de.plushnikov.intellij.plugin.provider.LombokAugmentProvider Maven / Gradle / Ivy

Go to download
package de.plushnikov.intellij.plugin.provider;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;

import org.jetbrains.annotations.NotNull;

import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.DumbService;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifierList;
import com.intellij.psi.augment.PsiAugmentProvider;
import de.plushnikov.intellij.lombok.UserMapKeys;
import de.plushnikov.intellij.lombok.processor.clazz.LombokClassProcessor;
import de.plushnikov.intellij.lombok.processor.field.LombokFieldProcessor;
import de.plushnikov.intellij.lombok.util.PsiClassUtil;
import de.plushnikov.intellij.plugin.core.GenericServiceLocator;

/**
 * Provides support for lombok generated elements
 *
 * @author Plushnikov Michail
 */
public class LombokAugmentProvider extends PsiAugmentProvider {
  private static final Logger LOG = Logger.getInstance(LombokAugmentProvider.class.getName());

  private final Collection allFieldHandlers;
  private final Collection allClassHandlers;

  public LombokAugmentProvider() {
    List lombokClassProcessors = GenericServiceLocator.locateAll(LombokClassProcessor.class);
    List lombokFieldProcessors = GenericServiceLocator.locateAll(LombokFieldProcessor.class);

    allClassHandlers = new HashSet(lombokClassProcessors);
    allFieldHandlers = new HashSet(lombokFieldProcessors);
  }

  @NotNull
  @Override
  public  List getAugments(@NotNull PsiElement element, @NotNull Class type) {
    List result = Collections.emptyList();
    // Expecting that we are only augmenting an PsiClass
    // Don't filter !isPhysical elements or code autocompletion will not work
    if (!(element instanceof PsiClass) || !element.isValid()) {
      return result;
    }
    // skip processing during index rebuild
    if (DumbService.getInstance(element.getProject()).isDumb()) {
      return result;
    }

    result = new ArrayList();
    final PsiClass psiClass = (PsiClass) element;

    if (type.isAssignableFrom(PsiField.class)) {
      LOG.info("collect field of class: " + psiClass.getQualifiedName());
      processPsiClassAnnotations(result, psiClass, type);

    } else if (type.isAssignableFrom(PsiMethod.class)) {
      LOG.info("collect methods of class: " + psiClass.getQualifiedName());

      cleanAttributeUsage(psiClass);
      processPsiClassAnnotations(result, psiClass, type);
      processPsiClassFieldAnnotation(result, psiClass, type);
    }
    return result;
  }

  protected void cleanAttributeUsage(PsiClass psiClass) {
    for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) {
      UserMapKeys.removeAllUsagesFrom(psiField);
    }
  }

  private  void processPsiClassAnnotations(@NotNull List result, @NotNull PsiClass psiClass, @NotNull Class type) {
    final PsiModifierList modifierList = psiClass.getModifierList();
    if (modifierList != null) {
      for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) {
        processClassAnnotation(psiAnnotation, psiClass, result, type);
      }
    }
  }

  private  void processClassAnnotation(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull List result, @NotNull Class type) {
    for (LombokClassProcessor classProcessor : allClassHandlers) {
      if (classProcessor.acceptAnnotation(psiAnnotation, type)) {
        classProcessor.process(psiClass, psiAnnotation, result);
      }
    }
  }

  protected  void processPsiClassFieldAnnotation(@NotNull List result, @NotNull PsiClass psiClass, @NotNull Class type) {
    for (PsiField psiField : psiClass.getFields()) {
      processField(result, psiField, type);
    }
  }

  protected  void processField(@NotNull List result, @NotNull PsiField psiField, @NotNull Class type) {
    final PsiModifierList modifierList = psiField.getModifierList();
    if (modifierList != null) {
      for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) {
        processFieldAnnotation(psiAnnotation, psiField, result, type);
      }
    }
  }

  private  void processFieldAnnotation(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull List result, @NotNull Class type) {
    for (LombokFieldProcessor fieldProcessor : allFieldHandlers) {
      if (fieldProcessor.acceptAnnotation(psiAnnotation, type)) {
        fieldProcessor.process(psiField, psiAnnotation, result);
      }
    }
  }

}