public static List validateMethods()

in litho-processor/src/main/java/com/facebook/litho/specmodels/model/DelegateMethodValidation.java [127:250]
110 lines of code
13 McCabe index (conditional complexity)

  public static List<SpecModelValidationError> validateMethods(
      SpecModel specModel,
      Map<Class<? extends Annotation>, DelegateMethodDescription> delegateMethodDescriptions,
      Map<Class<? extends Annotation>, Class<? extends Annotation>> interStageInputsMap) {
    List<SpecModelValidationError> validationErrors = new ArrayList<>();

    for (SpecMethodModel<DelegateMethod, Void> delegateMethod : specModel.getDelegateMethods()) {
      validationErrors.addAll(validateMethodIsStatic(specModel, delegateMethod));
      validationErrors.addAll(validateMethodName(delegateMethod));
    }

    for (Map.Entry<Class<? extends Annotation>, DelegateMethodDescription> entry :
        delegateMethodDescriptions.entrySet()) {
      final Class<? extends Annotation> delegateMethodAnnotation = entry.getKey();
      final DelegateMethodDescription delegateMethodDescription = entry.getValue();

      final SpecMethodModel<DelegateMethod, Void> delegateMethod =
          SpecModelUtils.getMethodModelWithAnnotation(specModel, delegateMethodAnnotation);

      if (delegateMethod == null) {
        continue;
      }
      final ImmutableList<TypeName> allowedDelegateMethodArgs =
          delegateMethodDescription.allowedDelegateMethodArguments();

      validationErrors.addAll(
          validateDefinedParameterTypes(
              delegateMethod, delegateMethodAnnotation, allowedDelegateMethodArgs));

      validationErrors.addAll(
          validateReturnType(delegateMethod, delegateMethodAnnotation, delegateMethodDescription));

      int numberOfAllowedMethodArgsUsed =
          getNumberOfAllowedMethodArgsUsed(delegateMethod.methodParams, allowedDelegateMethodArgs);

      for (int i = numberOfAllowedMethodArgsUsed, size = delegateMethod.methodParams.size();
          i < size;
          i++) {
        final MethodParamModel delegateMethodParam = delegateMethod.methodParams.get(i);
        if (isOptionalParameter(delegateMethodParam, delegateMethodDescription.optionalParameters)
            && i
                < numberOfAllowedMethodArgsUsed
                    + delegateMethodDescription.optionalParameters.size()) {
          continue;
        }

        if (delegateMethodParam instanceof InterStageInputParamModel
            || delegateMethodParam instanceof PrepareInterStageInputParamModel) {
          final Annotation annotation =
              getInterStageInputAnnotation(
                  delegateMethodParam, delegateMethodDescription.interStageInputAnnotations);

          if (annotation == null) {
            validationErrors.add(
                new SpecModelValidationError(
                    delegateMethodParam.getRepresentedObject(),
                    "Inter-stage input annotation is not valid for methods annotated with "
                        + delegateMethodAnnotation
                        + "; please use one "
                        + "of the following: "
                        + delegateMethodDescription.interStageInputAnnotations));
          } else {
            final Class<? extends Annotation> interStageOutputMethodAnnotation =
                interStageInputsMap.get(annotation.annotationType());

            final SpecMethodModel<DelegateMethod, Void> interStageOutputMethod =
                SpecModelUtils.getMethodModelWithAnnotation(
                    specModel, interStageOutputMethodAnnotation);

            if (interStageOutputMethod == null) {
              validationErrors.add(
                  new SpecModelValidationError(
                      delegateMethodParam.getRepresentedObject(),
                      "To use "
                          + annotation.annotationType()
                          + " on param "
                          + delegateMethodParam.getName()
                          + " you must have a method annotated "
                          + "with "
                          + interStageOutputMethodAnnotation
                          + " that has a param "
                          + "Output<"
                          + delegateMethodParam.getTypeName().box()
                          + "> "
                          + delegateMethodParam.getName()));
            } else if (!hasMatchingInterStageOutput(interStageOutputMethod, delegateMethodParam)) {
              validationErrors.add(
                  new SpecModelValidationError(
                      delegateMethodParam.getRepresentedObject(),
                      "To use "
                          + annotation.annotationType()
                          + " on param "
                          + delegateMethodParam.getName()
                          + " your method annotated "
                          + "with "
                          + interStageOutputMethodAnnotation
                          + " must have a param "
                          + "Output<"
                          + delegateMethodParam.getTypeName().box()
                          + "> "
                          + delegateMethodParam.getName()));
            }

            validateUniqueInterStatePropNames(
                interStageOutputMethodAnnotation,
                delegateMethodParam.getName(),
                specModel,
                validationErrors);
          }
        } else if (!isOptionalParamValid(
            specModel, delegateMethodDescription.optionalParameterTypes, delegateMethodParam)) {
          validationErrors.add(
              new SpecModelValidationError(
                  delegateMethodParam.getRepresentedObject(),
                  "Argument at index "
                      + i
                      + " is "
                      + getOptionalParamsError(delegateMethodDescription)));
        }
      }
    }

    return validationErrors;
  }