wildcardBoundUsesImplicitlyRecursiveBoundedWildcard(UseList<? extends List<Enum<?>>> arg) {
      return isSubtype(arg);
    }

    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public UseList<? extends List<Enum<? extends Enum<?>>>>
        wildcardBoundHasImplicitBoundAtsInvariantPosition(UseList<? extends List<Enum<?>>> arg) {
      return isSubtype(arg);

    def "task can take as input a collection of enum type from various sources"() {
        def buildSrcEnum = file("buildSrc/src/main/java/BuildSrcEnum.java")
        buildSrcEnum << """
public enum BuildSrcEnum {
    E1, E2
}
"""
        def otherScript = file("other.gradle")
        otherScript << """
enum ScriptPluginEnum {
    E1, E2
}
ext.pluginValue = ScriptPluginEnum.E1
"""

      }
    };
  }

  enum QueueImpl implements CollectionsImplEnum {
    MinMaxPriorityQueueImpl {
      @Override
      public <E extends Comparable<E>> Queue<E> create(Collection<E> contents) {
        return MinMaxPriorityQueue.create(contents);
      }
    };
  }

  enum TableImpl {
    HashBasedTableImpl {
      @Override

	ret.Pattern = v.Pattern
	ret.MaxItems = v.MaxItems
	ret.MinItems = v.MinItems
	ret.UniqueItems = v.UniqueItems
	ret.MultipleOf = v.MultipleOf
	if v.Enum != nil {
		ret.Enum = make([]interface{}, 0, len(v.Enum))
		for i := range v.Enum {
			ret.Enum = append(ret.Enum, v.Enum[i].Object)
		}
	}
	ret.MaxProperties = v.MaxProperties
	ret.MinProperties = v.MinProperties
	ret.Required = v.Required
	for i := range v.AllOf {

/^\/\// || /^#/ || NF == 0 { next }

# Ignore unchecked declarations.
/\/\*unchecked/ { next }

# Check enum values.
!enum && ($1 == "enum" || $2 == "enum") && $NF == "{" {
	enum = 1
	next
}
enum && $1 == "};" {
	enum = 0
	next
}
enum && /^}.*;$/ {
	enum = 0
	next
}
enum && NF == 3 && $2 == "=" {
	name = $1
	sub(/^GO_/, "", name)
	val = $3
	sub(/,$/, "", val)

				if strings.Contains(prop.Description, "enum") {
					enumAppeared = true
					if !tc.shouldHaveEnum {
						t.Errorf("enum appeared, description: %s", prop.Description)
					}
				}
				if len(prop.Enum) != 0 {
					enumAppeared = true
					if !tc.shouldHaveEnum {
						t.Errorf("enum appeared, enum: %v", prop.Enum)
					}
				}
			}
			if !enumAppeared && tc.shouldHaveEnum {

<expr>enum class Enum(val i: Int) {
    TEST(45),
    PROBE(45),
    SONDE(45)

  // NEXT ID: 4
  enum QuantizationComponent {
    COMPONENT_UNSPECIFIED = 0;
    COMPONENT_ACTIVATION = 1;
    COMPONENT_WEIGHT = 2;
    COMPONENT_BIAS = 3;
  }

  // NEXT ID: 5
  enum BitWidth {
    BIT_WIDTH_UNSPECIFIED = 0;
    BIT_WIDTH_4 = 1;
    BIT_WIDTH_8 = 2;
    BIT_WIDTH_16 = 3;
    BIT_WIDTH_32 = 4;
  }

  // NEXT ID: 4
  enum BitType {
    BIT_TYPE_UNSPECIFIED = 0;

            return this;
        }
        return snapshotter.snapshot(value);
    }

    private boolean isEqualEnum(@Nullable Object value) {
        if (value instanceof Enum<?>) {
            Enum<?> enumValue = (Enum<?>) value;
            return enumValue.name().equals(name) && enumValue.getDeclaringClass().getName().equals(className);
        }
        return false;
    }

    @Override

enum class Enum(val i: Int) {

    TEST(45),
    PROBE(45),
    SONDE(45);

    <expr>constructor(x: String) : this(x.length)</expr>