testSuiteBinary.getInputs().withType(DependentSourceSet.class).all(new Action<DependentSourceSet>() {
                @Override
                public void execute(DependentSourceSet testSource) {
                    testSource.lib(testedBinary.getInputs());
                }
            });
            testedBinary.getInputs().all(new Action<LanguageSourceSet>() {
                @Override

                mapInput = mapOf("a" to "b")
                mapInput = provider { null }
                mapInput = provider { mapOf("a" to "b") }
                setInput = null
                setInput = listOf("a")
                setInput = provider { null }
                setInput = provider { listOf("a") }
                listInput = null
                listInput = listOf("a")
                listInput = provider { null }

            getInputs().property(specPropertyName + ".caseSensitive", (Callable<Boolean>) spec::isCaseSensitive);
            getInputs().property(specPropertyName + ".includeEmptyDirs", (Callable<Boolean>) spec::getIncludeEmptyDirs);
            getInputs().property(specPropertyName + ".duplicatesStrategy", (Callable<DuplicatesStrategy>) spec::getDuplicatesStrategy);

  void runOnOperation() override;
};

LogicalResult ReorderReplicateAndPartitionedInputs(
    TF::TPUReplicatedInputOp replicated_input) {
  if (!llvm::all_of(replicated_input.getInputs(), [](Value input) {
        return llvm::isa_and_nonnull<TF::TPUPartitionedInputV2Op>(
            input.getDefiningOp());
      }))
    return replicated_input.emitOpError()

    public interface RootInterface {
        public String getInputs()
    }

    public interface RootInterfaceSub extends RootInterface {}

    public class ImplementingRootClass implements RootInterface {
        public String getInputs() { return "super" }
    }

    public class ImplementingRootClassSub extends ImplementingRootClass {
        public String getInputs() { return "concrete" }
    }

    }

    @Override
    public Collection<NativeLibraryBinary> getDependentBinaries() {
        return resolve(getInputs().withType(DependentSourceSet.class)).getAllLibraryBinaries();
    }

    @Override
    public Collection<NativeBinaryRequirementResolveResult> getAllResolutions() {
        return resolve(getInputs().withType(DependentSourceSet.class)).getAllResolutions();
    }

    @Override

                return sourceSet.getSource();
            }
        };

        return new LanguageSourceSetCollectionAdapter(getComponentName() + " source files", binary.getInputs(), filter, transform);
    }

    @Override
    public FileCollection getResourceFiles() {
        Spec<LanguageSourceSet> filter = new Spec<LanguageSourceSet>() {
            @Override

 public:
  using OpConversionPattern::OpConversionPattern;
  LogicalResult matchAndRewrite(
      mhlo::ReduceOp reduce_op, OpAdaptor adaptor,
      ConversionPatternRewriter& rewriter) const final {
    if (reduce_op.getInputs().size() != 2) return failure();
    if (reduce_op.getDimensions().getNumElements() != 1) return failure();

    // Check that the operand init is the expected value.
    DenseElementsAttr operand_init;

            for (NativeResourceSet windowsResourceSet : getInputs().withType(NativeResourceSet.class)) {
                if (!windowsResourceSet.getSource().isEmpty()) {
                    return true;
                }
            }
            return false;
        }

        private boolean hasExportedSymbols() {
            for (LanguageSourceSet languageSourceSet : getInputs()) {

            assign_var.getResource().getDefiningOp());
    if (!partitioned_input ||
        !AllResourceTypesHaveSubtypes(partitioned_input.getInputs().getTypes()))
      continue;

    const auto inputs = partitioned_input.getInputs();
    const bool packed_input = partitioned_input.getIsPacked();
    int num_cores_per_replica = partitioned_input.getN();
    if (num_cores_per_replica_attr) {