!anything.isAssignableFrom(extendsTypeVar)
    }

    def "asSubtype"() {
        expect:
        ModelType.of(String).asSubtype(ModelType.of(String)) == ModelType.of(String)
        ModelType.of(String).asSubtype(ModelType.of(CharSequence)) == ModelType.of(String)
    }

    def "asSubtype failures"() {
        def extendsString = new ModelType<List<? extends String>>() {}.typeVariables[0]

            context.add(ruleDefinition, "The first parameter of a method " + getDescription() + " must be a subtype of " + RuleSource.class.getName());
        }
        if (context.hasProblems()) {
            return null;
        }

        ModelType<? extends RuleSource> ruleSourceType = ruleType.asSubtype(RULE_SOURCE_MODEL_TYPE);

                                                expectedDependency.getDisplayName()));
                    return;
                }
                dependency = reference.getType().asSubtype(expectedDependency);
            }
        }

        if (dependency == null) {

                return baseItemModelType;
            }
            if (baseItemModelType.isAssignableFrom(targetItemClass)) {
                return targetItemClass.asSubtype(baseItemModelType);
            }
            return null;
        }
        if (targetClass.isAssignableFrom(ModelMap.class)) {
            return baseItemModelType;
        }
        return null;
    }

        if (info == null) {
            context.add(ruleDefinition, String.format("Type '%s' is not a subtype of '%s'.", builtType.toString(), COMPONENT_SPEC_MODEL_TYPE.toString()));
            return null;
        }

        return new ExtractedTypeRule(ruleDefinition, info, builtType.asSubtype(info.baseInterface));
    }

     *
     * @throws ClassCastException if this cannot be cast as the subtype of the given type.
     * @throws IllegalStateException if this is a wildcard.
     * @throws IllegalArgumentException if the given type is a wildcard.
     */
    public <U> ModelType<? extends U> asSubtype(ModelType<U> modelType) {
        if (isWildcard()) {

  /** Call this in a {@link TestSubtype} public method asserting subtype relationship. */
  final <T> T isSubtype(T sub) {
    Type returnType = method.getGenericReturnType();
    Type paramType = getOnlyParameterType();
    TestSubtype spec = method.getAnnotation(TestSubtype.class);
    assertWithMessage("%s is subtype of %s", paramType, returnType)
        .that(TypeToken.of(paramType).isSubtypeOf(returnType))

# RUN: tf-mlir-translate -graphdef-to-mlir -tf-enable-shape-inference-on-import=false %s -tf-input-arrays=p,x,y,z,t -tf-input-shapes=10::10:10: -tf-input-data-types="DT_INT32,DT_VARIANT(10:DT_FLOAT),DT_INT8,DT_DOUBLE,DT_RESOURCE(10:DT_INT32)" -tf-output-arrays=p,x,y,z,t -o - | FileCheck %s -check-prefix=CHECK-SUBTYPE

      return notSubtype(arg); // isSubtype() currently incorrectly considers it a subtype.
    }
  }

  private static class WildcardSubtypingTests extends SubtypeTester {
    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public Iterable<?> noBounds(List<?> list) {
      return isSubtype(list);
    }

      return notSubtype(arg); // isSubtype() currently incorrectly considers it a subtype.
    }
  }

  private static class WildcardSubtypingTests extends SubtypeTester {
    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public Iterable<?> noBounds(List<?> list) {
      return isSubtype(list);
    }