//===----------------------------------------------------------------------===//

bool GeneratorDatasetRegionOp::areTypesCompatible(Type t1, Type t2) {
  return true;  // Don't enforce type checking across control-flow edges.
}

void GeneratorDatasetRegionOp::getRegionInvocationBounds(
    ArrayRef<Attribute> operands,
    SmallVectorImpl<InvocationBounds>& invocationBounds) {

	// Otherwise, it is ignored.
	GetPC func(block, value ID) int64
}

type BlockDebug struct {
	// State at the start and end of the block. These are initialized,
	// and updated from new information that flows on back edges.
	startState, endState abt.T
	// Use these to avoid excess work in the merge. If none of the
	// predecessors has changed since the last check, the old answer is
	// still good.
	lastCheckedTime, lastChangedTime int32

  ASSERT_EQ(1, TF_OperationNumInputs(neg));
  TF_Output neg_input = TF_OperationInput({neg, 0});
  EXPECT_EQ(scalar, neg_input.oper);
  EXPECT_EQ(0, neg_input.index);

  // Test that we can't see control edges involving the source and sink nodes.
  TF_Operation* control_ops[100];
  EXPECT_EQ(0, TF_OperationNumControlInputs(scalar));
  EXPECT_EQ(0, TF_OperationGetControlInputs(scalar, control_ops, 100));

			// pass as meta-data file for "a" (emitted during the
			// package "a" build) to the package "c" run action, so
			// that it can be incorporated with "c"'s regular
			// metadata. To do this, we add edges from each compile
			// action to a "writeCoverMeta" action, then from the
			// writeCoverMeta action to each run action. Updated
			// graph:
			//
			//	build("a")       build("b")         build("c")

		extraPages := physPageSize / pageSize

		// Find a big enough region first, but then only allocate the
		// aligned portion. We can't just allocate and then free the
		// edges because we need to account for scavenged memory, and
		// that's difficult with alloc.
		//
		// Note that we skip updates to searchAddr here. It's OK if
		// it's stale and higher than normal; it'll operate correctly,

  let constructor = "TFTPU::CreateTPUColocateSplitsPass()";
  let description = [{
    It is beneficial for performance to assign a `Split` op to the same device
    as its predecessor. This is because the weight of cut edges is always
    minimized when the `Split` is with its predecessor. This colocation
    constraint will be used by the placer graph optimization to assign a device
    to the op.

- [`KT-58191`](https://youtrack.jetbrains.com/issue/KT-58191) K2: capturing closures successors that are already resolved (thanks to backward edges) must be taken into account for allowing smart casts
- [`KT-67144`](https://youtrack.jetbrains.com/issue/KT-67144) K2: potential NPE when assigning to unstable vars

  invocationBounds.emplace_back(InvocationBounds::getUnknown());
}

bool WhileRegionOp::areTypesCompatible(Type t1, Type t2) {
  // For now, we don't enforce type checking across control-flow edges.
  return true;
}

//===----------------------------------------------------------------------===//
// WhileRegionOp canonicalization

Class <org.gradle.execution.plan.edges.ComplexDependencyNodesSet> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ComplexDependencyNodesSet.java:0)
Class <org.gradle.execution.plan.edges.ComplexDependentNodesSet> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ComplexDependentNodesSet.java:0)

    [HasParent<"mlir::func::FuncOp">, RecursiveMemoryEffects, SingleBlockImplicitTerminator<"YieldOp">]> {
  let summary = [{
    The `TFL.control_node` operation wraps single-block operations in order to attach control edges.
  }];

  let description = [{
    This is used to wrap regions and attach control dependencies to them. Typically,
    this will happen in one of the last steps before emitting the flatbuffer model