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;
};

			"cap": nil,
			"len": nil,
			"new": nil,
			"make": nil,
			"panic": nil,
			"panicln": nil,
			"print": nil,
			"println": nil,
		},
	}
}


// alignment of map composite entries
var _ = map[int]int{
	// small key sizes: always align even if size ratios are large
	a: a,
	abcdefghabcdefgh: a,
	ab: a,
	abc: a,
	abcdefgabcdefg: a,
	abcd: a,
	abcde: a,
	abcdef: a,

    }

    def 'constructs empty tree when composite tree created with empty list'() {
        def tree = factory.treeOf([])

        expect:
        emptyTree(tree)
    }

    def 'returns source file tree when composite tree created with single entry'() {
        def source = Stub(FileTreeInternal)
        def tree = factory.treeOf([source])

			"cap":		nil,
			"len":		nil,
			"new":		nil,
			"make":		nil,
			"panic":	nil,
			"panicln":	nil,
			"print":	nil,
			"println":	nil,
		},
	}
}

// alignment of map composite entries
var _ = map[int]int{
	// small key sizes: always align even if size ratios are large
	a:			a,
	abcdefghabcdefgh:	a,
	ab:			a,
	abc:			a,
	abcdefgabcdefg:		a,
	abcd:			a,
	abcde:			a,

    }

    // 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).

			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).