graphMetadata.getVariantsForGraphTraversal().stream()
                .map(ModuleConfigurationMetadata.class::cast)
                .map(variant -> resolveStateFor(variant).asVariant())
                .collect(Collectors.toList())
        );
        this.idGenerator = idGenerator;
        this.selectableVariantResults = graphMetadata.getVariantsForGraphTraversal().stream()

    String getName();

    ImmutableAttributes getAttributes();

    /**
     * Returns a view of this configuration that can be used as a variant.
     */
    VariantGraphResolveState asVariant();

    ConfigurationGraphResolveMetadata getMetadata();

                idGenerator.nextVariantId(), component, component.getMetadata(), configuration, calculatedValueContainerFactory
            ).asVariant();

            if (!configuration.getAttributes().isEmpty()) {
                configurationsWithAttributes.add(variantState);
            }

        toConfig.name >> name
        toConfig.getHierarchy() >> ImmutableSet.of(name)
        def toState = Stub(ConfigurationGraphResolveState)
        toState.metadata >> toConfig
        toState.asVariant() >> { throw new RuntimeException() }
        return toState
    }

    def "configuration mapping can use all-except-wildcard on LHS"() {
        def resolutionFailureHandler = Stub(ResolutionFailureHandler)

            throw new IllegalArgumentException(String.format("Expected configuration '%s' to be present in %s", configurationName, componentIdentifier));
        }
        VariantGraphResolveState rootVariant = configuration.asVariant();

        return new RootComponentState() {
            @Override
            public LocalComponentGraphResolveState getRootComponent() {
                return state;
            }

            @Override

        ImmutableList.Builder<VariantGraphResolveState> builder = ImmutableList.builderWithExpectedSize(targets.size());
        for (ConfigurationGraphResolveState target : targets) {
            builder.add(target.asVariant());
        }

        return new GraphVariantSelectionResult(builder.build(), false);
    }

            getMetadata() >> configurationMetadata
        }
        Stub(TestConfigurationState) {
            getName() >> name
            getMetadata() >> configurationMetadata
            asVariant() >> variant
            getAttributes() >> attrs
        }
    }

    private VariantGraphResolveState defaultConfiguration(ImmutableAttributes attrs = attributes([:])) {

  if (MatchesPattern(op, supported_ops)) return true;

  auto abstractOp = op.getRegisteredInfo();
  if (!abstractOp) return false;
  return mlir::mhlo::HasTf2XlaFallback(abstractOp->getTypeID());
}

bool IsVariant(Value value) {
  return mlir::isa<mlir::TF::VariantType>(
      getElementTypeOrSelf(value.getType()));
}

bool HasOutsideCompiledAncestor(Operation* op) {
  Operation* parent = op->getParentOp();