const std::string& SignatureDefParam::name() const { return name_; }

const TensorSpec& SignatureDefParam::spec() const { return spec_; }

SignatureDefFunctionMetadata::SignatureDefFunctionMetadata(
    std::vector<SignatureDefParam> arguments,
    std::vector<SignatureDefParam> returns)
    : arguments_(std::move(arguments)), returns_(std::move(returns)) {}

                               std::vector<SignatureDefParam> returns);

  const std::vector<SignatureDefParam>& arguments() const;
  const std::vector<SignatureDefParam>& returns() const;

 private:
  std::vector<SignatureDefParam> arguments_;
  std::vector<SignatureDefParam> returns_;
};

}  // namespace tensorflow

  absl::flat_hash_map<Operation*, Node*> nodes_;
  llvm::DenseMap<BlockArgument, Node*> args_;
  // One single return operation can return multiple results, and each of them
  // will be converted to one node in the graph.
  typedef absl::InlinedVector<Node*, 4> NodeVector;
  absl::flat_hash_map<Operation*, NodeVector> returns_;
  const mlir::Dialect* tf_dialect_;
  const SymbolTable& symbol_table_;
};

  absl::flat_hash_map<Operation*, Node*> nodes_;
  llvm::DenseMap<BlockArgument, Node*> args_;
  // One single return operation can return multiple results, and each of them
  // will be converted to one node in the graph.
  typedef absl::InlinedVector<Node*, 4> NodeVector;
  absl::flat_hash_map<Operation*, NodeVector> returns_;
  const mlir::Dialect* tf_dialect_;
  const SymbolTable& symbol_table_;
};

func returnsFunc(x int) func(int) int {
	if x < 0 {
		G++
	}
	return adder
}

func returnsFunc2() func(int) int {
	return func(x int) int {
		return adder(x)
	}
}

func returnsNonInlinableFunc() func(int) int {
	return adderNoInline
}

func multiReturnsFunc() (int, func(int) int, int) {
	return 42, func(x int) int { G++; return 1 }, -42
}

func adder(x int) int {
	G += 1
	return G

fun foo(a: Int): Int {
    a.let {
        <expr>if (it > 0) return@foo it else return -it</expr>
    }
    return 0

fun foo(a: Int): Int {
    val b: Int = 1
    <expr>when (a + b) {
        0 -> return 0
        1 -> consume(1)
        else -> consume(2)
    }
    </expr>
    return 1
}

  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return it,
    return@foo -it
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return it,
    return@foo -it
  ]

  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return@foo it,
    return -it
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return@foo it,
    return -it
  ]

    expression = if (a + b > 0) return 0
        else if (a - b < 0) consume(a - b)
        else consume(0)
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return 0
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return 0
  ]