const llvm::MemoryBuffer* input =
      source_mgr->getMemoryBuffer(source_mgr->getMainFileID());
  std::string error;
  auto loc =
      mlir::FileLineColLoc::get(context, input->getBufferIdentifier(), 0, 0);
  std::vector<std::string> inputs;
  std::vector<std::string> outputs;
  return tflite::FlatBufferToMlir(
      absl::string_view(input->getBufferStart(), input->getBufferSize()),

	meta := analysis.Metadata{
		Name:        "webhook.Analyzer",
		Description: "Checks the validity of Istio webhooks",
		Inputs: []config.GroupVersionKind{
			gvk.MutatingWebhookConfiguration,
		},
	}
	if !a.SkipServiceCheck {
		meta.Inputs = append(meta.Inputs, gvk.Service)
	}
	return meta
}

func getNamespaceLabels() []klabels.Set {
	return []klabels.Set{
		{},

                continue;
            }
            File outputLocation = report.getOutputLocation().get().getAsFile();
            inputs.add(new ReportState(report.getDisplayName(), outputLocation, outputLocation.exists()));
        }
        return inputs;
    }

    private Set<Report> getEnabledInputReports() {
        HashSet<Reporting<? extends ReportContainer<?>>> allAggregatedReports = Sets.newHashSet(aggregated);

  const llvm::MemoryBuffer* input =
      source_mgr->getMemoryBuffer(source_mgr->getMainFileID());
  std::string error;
  auto loc =
      mlir::FileLineColLoc::get(context, input->getBufferIdentifier(), 0, 0);

  // Parses input/output names from command line options.
  std::vector<std::string> inputs;
  std::vector<std::string> outputs;

    def "ad hoc tasks with the same action share results"() {
        file("input.txt").text = "data"
        buildFile << """
            def input = file("input.txt")
            def action = {
                println "Same action"
            }

            task taskA {
                def output = file("build/task-a/output.txt")
                inputs.file input
                outputs.file output
                outputs.cacheIf { true }

      func.func @main(%arg_0: tensor<!tf_type.string> {tf_saved_model.bound_input = @__tf_saved_model_asset0}) -> () attributes {tf.entry_function = {inputs = "arg_0:0", outputs = ""}} {
        return
      }
    }
  )mlir");

  FailureOr<SmallVector<AssetFileDef>> asset_file_defs =
      ConvertAssetArgs(*module_op);

  EXPECT_TRUE(succeeded(asset_file_defs));

        // Once we migrate to all-scheduled transforms we should consider if we can avoid having this optimization and use only normalized inputs.
        //
        // Note that we are not capturing this value in the actual inputs of the work; doing so would cause unnecessary cache misses.
        // This is why the hash is captured here and not in visitIdentityInputs().

                                PatternRewriter& rewriter) const override {
    MLIRContext* ctx = reduce_op.getContext();
    ValueRange inputs = reduce_op.getInputs();
    // Only handle binary reduce ops for now
    if (inputs.size() != 1) return failure();
    Value reduce_input = inputs[0];

    RankedTensorType reduce_type =
        reduce_op.getResultTypes()[0].cast<RankedTensorType>();

    $metadata is a serialized TPUCompileMetadataProto describing the shapes and types of the inputs to the computation, as well as a mapping onto the TPU pod topology.
    $constant_operand_indices are the indices of the inputs that are constant to the TPU program (e.g. weights in inference), the rest of the inputs are input tensors.
    constant_operand_indices is sorted in ascending order.

// RUN: tf-opt %s -split-input-file -verify-diagnostics -tf-xla-validate-inputs

// expected-error @+1 {{expects no nested calls of entry functions as they prevent graph traversal in some passes from working correctly}}
func.func @nested_entry_functions() attributes {tf.entry_function = {}} {
  tf_executor.graph {