private void validateTypeAndAnnotations() {
    if (typeKind.isContainerKind() && typeParameters.isEmpty()) {
      typeKind = AttributeTypeKind.REGULAR;
      if (!SuppressedWarnings.forElement(element, false, false).rawtypes) {
        report().warning(About.UNTYPE,
            "Raw container types treated as regular attributes, nothing special generated."
                + " It is better to avoid raw types at all times");
      }
    }

    if (typeKind.isContainerKind()) {
      boolean hasWildcardInType = returnTypeName.indexOf('?') >= 0;
      if (hasWildcardInType) {
        if (hasNakedWildcardArguments()) {
          typeKind = AttributeTypeKind.REGULAR;
          report()
              .annotationNamed(DefaultMirror.simpleName())
              .warning(About.UNTYPE,
                  "Wildcards are not supported as elements or key/values. Make it lose its special treatment");
        }
      }
    }

    if (isNullable()) {
      if (isOptionalType()) {
        typeKind = AttributeTypeKind.REGULAR;
        report()
            .annotationNamed(DefaultMirror.simpleName())
            .warning(About.UNTYPE, "@Nullable on a Optional attribute make it lose its special treatment");
      } else if (isPrimitive()) {
        report()
            .annotationNamed(nullability.simpleName())
            .error("@%s could not be used with primitive type attibutes", nullability.simpleName());
      } else if (containingType.isAnnotationType()) {
        report()
            .annotationNamed(nullability.simpleName())
            .error("@%s could not be used with annotation attribute, use default value", nullability.simpleName());
      }
    }

    if (isGenerateDefault && isOptionalType()) {
      typeKind = AttributeTypeKind.REGULAR;
      report()
          .annotationNamed(DefaultMirror.simpleName())
          .warning(About.UNTYPE, "@Value.Default on a optional attribute make it lose its special treatment");
    }

    if (isContainerType() && containingType.isUseStrictBuilder()) {
      if (isGenerateDefault) {
        typeKind = AttributeTypeKind.REGULAR;
        report()
            .annotationNamed(DefaultMirror.simpleName())
            .warning(About.UNTYPE,
                "@Value.Default on a container attribute make it lose its special treatment (when strictBuilder = " +
                    "true)");
      } else if (isNullable()) {
        typeKind = AttributeTypeKind.REGULAR;
        report()
            .annotationNamed(nullability.simpleName())
            .warning(About.UNTYPE,
                "@%s on a container attribute make it lose its special treatment (when strictBuilder = true)",
                nullability.simpleName());
      }
    }

    if (containingType.isAnnotationType() && isAuxiliary()) {
      report()
          .annotationNamed(AuxiliaryMirror.simpleName())
          .error("@Value.Auxiliary cannot be used on annotation attribute to not violate annotation spec");
    }

    if (!isGenerateJdkOnly()
        && (nullElements == NullElements.ALLOW || nullElements == NullElements.SKIP)) {
      report().warning(About.INCOMPAT,
          "Guava collection implementation does not allow null elements,"
              + " @AllowNulls/@SkipNulls annotation will be ignored."
              + " Switch Style.jdkOnly=true to use collections that permit nulls as values");
    }

    if (isOptionalType()
        && containedTypeElement != null // for specialized optional types it can be null
        && AttributeTypeKind.forRawType(containedTypeElement.getQualifiedName().toString()).isOptionalKind()) {
      typeKind = AttributeTypeKind.REGULAR;
      report().warning(About.UNTYPE,
          "Optional<Optional<*>> is turned into regular attribute to avoid ambiguity problems");
    }
  }
Initialized Validates things that were not validated otherwise
@param instantiationCreator can instantiate encodings
value-processor/src/org/immutables/value/processor/meta/ValueAttribute.java