@Nullable
@Override
public ProblemDescriptor[] checkMethod(
    @NotNull PsiMethod method, @NotNull InspectionManager manager, boolean isOnTheFly) {
  if (!LithoPluginUtils.isLithoSpec(method.getContainingClass())) {
    return ProblemDescriptor.EMPTY_ARRAY;
  }
  return Optional.of(method)
      .map(PsiMethod::getParameterList)
      .map(PsiParameterList::getParameters)
      .map(
          psiParameters ->
              Stream.of(psiParameters)
                  .filter(LithoPluginUtils::isPropOrState)
                  .filter(UppercaseStatePropInspection::isFirstLetterCapital)
                  .map(PsiParameter::getNameIdentifier)
                  .filter(Objects::nonNull)
                  .map(identifier -> createWarning(identifier, manager, isOnTheFly))
                  .toArray(ProblemDescriptor[]::new))
      .orElse(ProblemDescriptor.EMPTY_ARRAY);
}
 

@Test
public void defaultValues() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        assertNotNull(prop);
        assertFalse(prop.optional());
        assertFalse(prop.isCommonProp());
        assertFalse(prop.overrideCommonPropBehavior());
        assertFalse(prop.dynamic());
        assertEquals(ResType.NONE, prop.resType());

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void setValues() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[1], Prop.class);
        assertNotNull(prop);
        assertTrue(prop.optional());
        assertTrue(prop.isCommonProp());
        assertTrue(prop.overrideCommonPropBehavior());
        assertTrue(prop.dynamic());
        assertEquals(ResType.DRAWABLE, prop.resType());

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyEquals_equal() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop1 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        Prop prop2 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[2], Prop.class);
        // Calls proxy
        assertEquals(prop1, prop2);

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyEquals_not_equal() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop1 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        Prop prop2 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[1], Prop.class);
        // Calls proxy
        assertNotEquals(prop1, prop2);

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyHashCode() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop1 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        Prop prop2 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[2], Prop.class);
        Set<Prop> props = new HashSet<>(1);
        props.add(prop1);
        props.add(prop2);
        // Calls proxy
        assertEquals(1, props.size());

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyToString() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        // Calls proxy
        assertEquals("@com.facebook.litho.annotations.Prop()", prop.toString());

        return true;
      },
      "WithAnnotationClass.java");
}
 

/**
 * Finds and removes a given method
 * @param methodName
 * @param arguments
 */
private void findAndRemoveMethod(String methodName, String... arguments) {
  // Maybe there's an easier way to do this with mClass.findMethodBySignature(), but I'm not an expert on Psi*
  PsiMethod[] methods = psiClass.findMethodsByName(methodName, false);

  for (PsiMethod method : methods) {
    PsiParameterList parameterList = method.getParameterList();

    if (parameterList.getParametersCount() == arguments.length) {
      boolean shouldDelete = true;

      PsiParameter[] parameters = parameterList.getParameters();

      for (int i = 0; i < arguments.length; i++) {
        if (!parameters[i].getType().getCanonicalText().equals(arguments[i])) {
          shouldDelete = false;
        }
      }

      if (shouldDelete) {
        method.delete();
      }
    }
  }
}
 

static boolean areParameterListsEqual(PsiParameterList paramList1, PsiParameterList paramList2) {
    if (paramList1.getParametersCount() != paramList2.getParametersCount()) {
        return false;
    }

    final PsiParameter[] param1Params = paramList1.getParameters();
    final PsiParameter[] param2Params = paramList2.getParameters();
    for (int i = 0; i < param1Params.length; i++) {
        final PsiParameter param1Param = param1Params[i];
        final PsiParameter param2Param = param2Params[i];

        if (!areTypesPresentableEqual(param1Param.getType(), param2Param.getType())) {
            return false;
        }
    }

    return true;
}
 

/** @return the Stream of unique parameters from all methods excluding current method. */
public static Stream<PsiParameter> getPsiParameterStream(
    @Nullable PsiMethod currentMethod, PsiMethod[] allMethods) {
  return Stream.of(allMethods)
      .filter(psiMethod -> !psiMethod.equals(currentMethod))
      .map(PsiMethod::getParameterList)
      .map(PsiParameterList::getParameters)
      .flatMap(Stream::of)
      .filter(distinctByKey(PsiParameter::getName));
}
 

@Before
public void setUp() throws Exception {
    holder = mock(AnnotationHolder.class);
    helper = mock(AnnotationHelper.class);
    textRange = mock(TextRange.class);
    element = mock(PsiMethod.class);
    parameterList = mock(PsiParameterList.class);
}
 

@Override public boolean shouldShow(Usage usage) {
  PsiElement element = ((UsageInfo2UsageAdapter) usage).getElement();
  if (element instanceof PsiJavaCodeReferenceElement) {
    if ((element = element.getContext()) instanceof PsiTypeElement) {
      if ((element = element.getContext()) instanceof PsiParameter) {
        if ((element = element.getContext()) instanceof PsiParameterList) {
          if ((element = element.getContext()) instanceof PsiMethod) {
            return SubscriberMetadata.isAnnotatedWithSubscriber((PsiMethod) element);
          }
        }
      }
    }
  }
  return false;
}
 

public static @Nullable PsiTypeElement getMethodParameter(PsiMethod subscribeMethod) {
  PsiParameterList parameterList = subscribeMethod.getParameterList();
  if (parameterList.getParametersCount() != 1) {
    return null;
  } else {
    PsiParameter subscribeMethodParam = parameterList.getParameters()[0];
    return subscribeMethodParam.getTypeElement();
  }
}
 

@NotNull
@Override
protected JavaParameterTableModel createParametersInfoModel(JavaMethodDescriptor descriptor) {
  final PsiParameterList parameterList = descriptor.getMethod().getParameterList();
  return new JavaParameterTableModel(parameterList, myDefaultValueContext, this);
}