std::unique_ptr<Impl> impl_;
  explicit Scope(Impl*);
};

/// A helper struct to hold the scopes that would be used by a function
/// constructing a composite op.
struct CompositeOpScopes {
  /// Scope to be used for creating the local ops (primitive or other composite
  /// ops).
  Scope child;
  /// Scope to be used for creating the last op.
  Scope last;
};

    }

    // This test mostly reproduces `org.gradle.plugins.ide.tooling.r31.PersistentCompositeDependencySubstitutionCrossVersionSpec.ensures unique name for all Idea modules in composite`
    def "ensures unique name for all Idea modules in composite"() {
        singleProjectBuildInRootDir("buildA") {
            buildFile << """
                apply plugin: 'java'
                dependencies {

        return failure();
      }

      // Quantization parameters can be propagated only for same-scale ops and
      // same-scale ops are quantized only when they are connected to quantized
      // composite functions.
      if (!GetStableHloQuantConstraints(op_with_region)
               ->has_same_scale_requirement ||
          !IsConnectedWithQuantizedCompsiteFunction(op_with_region)) {
        return failure();
      }

  let constructor = "CreatePostQuantizeRemoveQDQPass()";
}

def PrepareCompositeFunctionsPass : Pass<"tfl-prepare-composite-funcs-tf", "mlir::ModuleOp"> {
  let summary = "Prepares composite functions in Tensorflow dialect of MLIR.";
  let constructor = "CreatePrepareCompositeFunctionsPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
  let description = [{

     * we start with the plugins block, but the said plugin is provided by the composite.
     *
     * It actually works for the buildSrc application, but not for the main build
     */
    @ToBeImplemented
    def "can use a composite build to write a settings plugin which will apply to both the main build and buildSrc"() {
        withSettingsPlugin()

			check.errorf(x, code, invalidArg+"%s %s overflows int", what, x)
			return false
		}
	}

	return true
}

// indexedElts checks the elements (elts) of an array or slice composite literal
// against the literal's element type (typ), and the element indices against
// the literal length if known (length >= 0). It returns the length of the
// literal (maximum index value + 1).

	_ = !ok
	_ = x
}

func issue8799b(x int, ok bool) {
	x, ok = missing /* ERROR "undefined" */ ()
	_ = !ok
	_ = x
}

func issue9182() {
	type Point C /* ERROR "undefined" */ .Point
	// no error for composite literal based on unknown type
	_ = Point{x: 1, y: 2}
}

func f0() (a []int)         { return }
func f1() (a []int, b int)  { return }
func f2() (a, b []int)      { return }

func append_([]int, ...int) {}

 * limitations under the License.
 */

package org.gradle.integtests.composite


import org.gradle.integtests.fixtures.build.BuildTestFile
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.timeout.IntegrationTestTimeout
import spock.lang.Issue

/**
 * Tests for plugin development scenarios within a composite build.
 */

			check.errorf(x, code, invalidArg+"%s %s overflows int", what, x)
			return false
		}
	}

	return true
}

// indexedElts checks the elements (elts) of an array or slice composite literal
// against the literal's element type (typ), and the element indices against
// the literal length if known (length >= 0). It returns the length of the
// literal (maximum index value + 1).

    Gradle getGradle();

    /**
     * Includes a build at the specified path to the composite build.
     * @param rootProject The path to the root project directory for the build.
     *
     * @since 3.1
     */
    void includeBuild(Object rootProject);

    /**
     * Includes a build at the specified path to the composite build, with the supplied configuration.