type M interface {
	M()
}

var e interface{} = T{}
var i M = T{}
var b bool

func f1() int {
	if b {
		return f1() // convince inliner not to inline
	}
	z := 0x11223344
	_ = e.(T)
	return z
}

func f2() int {
	if b {
		return f1() // convince inliner not to inline
	}
	z := 0x11223344
	_ = i.(T)
	return z
}

func main() {
	x := f1()
	y := f2()
	if x != 0x11223344 || y != 0x11223344 {

  if (!nested_module) return;

  InlinerInterface inliner(&getContext());
  auto walk_result = getOperation().walk([&](TF::PartitionedCallOp call_op) {
    if (!call_op.getF().getRootReference().getValue().starts_with(
            kNestedModule))
      return WalkResult::advance();
    // This is a call we need to inline!
    LLVM_DEBUG(llvm::dbgs()
               << "Found call to inline: " << *call_op.getOperation() << "\n");

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// The inliner would erroneously scan the caller function's body for
// reassignments *before* substituting the inlined function call body,
// which could cause false positives in deciding when it's safe to
// transitively inline indirect function calls.

package main

func main() {
	bug1()
	bug2(fail)
}

func bug1() {

// license that can be found in the LICENSE file.

// Functions that the inliner exported incorrectly.

package one

type T int

// Issue 2678
func F1(T *T) bool { return T == nil }

// Issue 2682.
func F2(c chan int) bool { return c == (<-chan int)(nil) }

// Use of single named return value.
func F3() (ret []int) { return append(ret, 1) }

// Call of inlined method with blank receiver.
func (_ *T) M() int { return 1 }

// compiledir

// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Printing local variables in inliner shadows global names.

namespace mlir {
namespace TF {

inline constexpr char kStandardPipelineBefore[] = "standard_pipeline_before";
inline constexpr char kStandardPipelineAfter[] = "standard_pipeline_after";

// Runs all passes involved in transforming or optimizing an MLIR graph without
// any target specialization. When enable_logging is true, enables
// tensorflow::BridgeLogger. When enable_inliner is true, enables the inliner
// pass.
ABSL_DEPRECATED(

  AddShapeLegalizationPasses(pm);
  pm.addNestedPass<func::FuncOp>(
      CreateConvertCustomAggregationOpToQuantStatsPass());
  pm.addPass(createQuantizeCompositeFunctionsPass(options));
  // Add an inliner pass to inline quantized StableHLO functions.
  pm.addPass(createInlinerPass());
  if (pipeline_config.unpack_quantized_types()) {
    AddStablehloQuantToIntPasses(pm);
  }
}

void AddWeightOnlyQuantizationPasses(

// RUN: tf-opt -tf-shape-inference -inline='default-pipeline=''' %s | FileCheck %s --dump-input=always
// RUN: tf-opt -tf-standard-pipeline=enable-inliner %s | FileCheck %s --dump-input=always

// Tests function with argument has no resource subtype but caller operand has a
// resource subtype, and after shape inference, function argument is refined and
// no `tf.Cast` ops are generated.

    std::vector<std::string> hardware_backends;
    // Debug mode.
    // This will output different alternative subgraphs in mlir format for debug
    // purpose.
    bool debug_mode = false;
    // Whether to enable inliner passes or not.
    bool enable_inliner = false;
    // Whether to legalize ops to TFLite ops before exporting.
    bool legalize_to_tflite_ops = false;
  };

  virtual ~TacModule() = default;

		}
	}

	{
		a := 2
		if r := func(x int) int { // ERROR "can inline main.func28"
			b := 3
			return func(y int) int { // ERROR "can inline main.func28.1" "can inline main.main.func28.func35"
				c := 5
				func(z int) { // ERROR "can inline main.func28.1.1" "can inline main.func28.main.func28.1.2" "can inline main.main.func28.func35.1" "can inline main.main.func28.main.main.func28.func35.func37"
					a = a * x
					b = b * y