func.func @main(%arg0 : tensor<!tf_type.variant<tensor<2xi32>>>, %arg1: tensor<!tf_type.variant<tensor<*xi32>>>) -> tensor<!tf_type.variant<tensor<2xi32>>> {
  func.return %arg0 : tensor<!tf_type.variant<tensor<2xi32>>>
}

// CHECK:          func.func @main(%[[ARG0:.*]]: tensor<!tf_type.variant<tensor<2xi32>>>, %[[ARG1:.*]]: tensor<!tf_type.variant<tensor<*xi32>>>) -> tensor<!tf_type.variant<tensor<2xi32>>>

        variant.dependencies[1].module == 'bar'
        variant.dependencies[1].version == null
        variant.dependencies[1].prefers == '1.0'
        variant.dependencies[1].strictly == null
        variant.dependencies[1].rejectsVersion == []

        variant.dependencies[2].group == 'org'
        variant.dependencies[2].module == 'baz'
        variant.dependencies[2].version == '2.0'

	HandSize int32 `json:"handSize" protobuf:"varint,2,opt,name=handSize"`

	// `queueLengthLimit` is the maximum number of requests allowed to
	// be waiting in a given queue of this priority level at a time;
	// excess requests are rejected.  This value must be positive.  If
	// not specified, it will be defaulted to 50.
	// +optional
	QueueLengthLimit int32 `json:"queueLengthLimit" protobuf:"varint,3,opt,name=queueLengthLimit"`
}

    }

    private static void assertAttributes(GradleModuleMetadata.Variant variant, Map<String, Object> expected) {
        assert variant.attributes.size() == expected.size()
        expected.each { attribute, value ->
            assert variant.attributes.containsKey(attribute)
            assert variant.attributes[attribute] == value
        }
    }

    void assertNoDependencies() {

    private final String libraryName;
    private final String variant;

    public DefaultLibraryBinaryDependencySpec(String projectPath, String libraryName, String variant) {
        if (libraryName == null || projectPath == null || variant == null) {
            throw new IllegalDependencyNotation("A direct library binary dependency must have all of project, library name and variant specified.");
        }
        this.libraryName = libraryName;

/**
 * The result of successfully resolving a component variant.
 *
 * @since 3.5
 */
public interface ResolvedVariantResult {
    /**
     * The component which owns this variant.
     *
     * @return the component identifier of this variant
     * @since 6.8
     */
    ComponentIdentifier getOwner();

    /**
     * The attributes associated with this variant.
     */
    AttributeContainer getAttributes();

        then:
        gmmMetadata.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        gmmMetadata.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        gmmMetadata.parsedModuleMetadata.variant("custom") {
            dependency('log4j:log4j:1.2.17').exists()
            noMoreDependencies()
        }

class VariantAspectExtractionIntegrationTest extends AbstractIntegrationSpec {
    def "variant annotation on property with illegal type raises error"() {
        buildFile << """
        @Managed
        interface SampleBinary extends BinarySpec {
            @Variant
            Integer getVariantProp()
            void setVariantProp(Integer variant)
        }
        class Rules extends RuleSource {
            @ComponentType

    func.return %4, %6 : tensor<!tf_type.variant>, tensor<!tf_type.variant>
  }
  // CHECK-LABEL: @funcB_renamed
  func.func private @funcB_renamed(%arg0: tensor<i64> {tf._user_specified_name = "args_0"}) -> tensor<!tf_type.variant> attributes {tf._original_func_name = "funcB", tf._tf_data_function = true, tf.signature.is_stateful} {

        /**
         * Executes the underlying action if the supplied variant matches.
         *
         * @param variant the variant metadata, used to check if the rule applies
         * @param subject the subject of the rule
         */
        public void maybeExecute(VariantResolveMetadata variant, T subject) {
            if (variantName == null || variantName.equals(variant.getName())) {
                delegate.execute(subject);