// The state for rescaling the propagated quantization parameters. This can be
// on the input side to satisfy the constraint of previous operation, or on the
// output side to satisfy the constraint of the next operation.
struct RequantizeState {
  // Sometimes, we have to "requantize" the quantization result to satisfy all
  // the constraints. The "requantize" can happen either on the input or output
  // of the quantization result.

            encoder.writeSmallInt(constraints.size());
            for (ComponentVariant.DependencyConstraint constraint : constraints) {
                componentSelectorSerializer.write(encoder, constraint.getGroup(), constraint.getModule(), constraint.getVersionConstraint(), constraint.getAttributes(), Collections.emptyList());

// Copyright 2021 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.

// This file contains test cases for interfaces containing
// constraint elements.

package p

type _ interface {
	m()
	~int
	~int|string
	E
}

type _ interface {
	m()
	~int
	int | string
	int | ~string
	~int | ~string
}

type _ interface {

    LocalOriginDependencyMetadata withTargetAndArtifacts(ComponentSelector target, List<IvyArtifactName> artifacts);

    @Override
    LocalOriginDependencyMetadata forced();

    /**
     * Is this a dependency constraint created for a dependency lock?
     */
    boolean isFromLock();

        then:
        if (supportedInMetadata(metadataType)) {
            assert dependencies.size() == 2
            assert dependencies[0].constraint == addAllDependenciesAsConstraints()
            assert dependencies[1].constraint == addAllDependenciesAsConstraints()
        } else {
            assert dependencies.empty
        }

        where:
        metadataType | metadataImplementation

// run

// Copyright 2021 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.

// Smoke test for constraint literals with elided interface
// per issue #48424.

package main

func identity[T int](x T) T {
	return x
}

func min[T int | string](x, y T) T {
	if x < y {
		return x
	}
	return y
}

            root(":", ":test:") {
                edge('org:foo', 'org:foo:1.0') {
                    byConstraint()
                    artifact(type: 'distribution-tgz')
                }
                constraint('org:foo:1.0')
            }
        }
    }

    def "The first artifact is used as replacement for metadata if multiple artifacts are declared using #declaration"() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.artifacts;

/**
 * Describes a dependency constraint declared in a resolved component's metadata, which typically originates from
 * a component descriptor (Gradle metadata file). This interface can be used to adjust

limitations under the License.
==============================================================================*/
include "stablehlo/dialect/StablehloOps.td"

class IsStringAttrOf<string value> : Constraint<
  CPred<"::llvm::isa_and_nonnull<StringAttr>($_self) && $_self.cast<StringAttr>().getValue() == \"" # value # "\"">,
  "Is a string attribute whose value is \"" # value # "\""
>;

  "GetScalarOfType(getElementTypeOrSelf($0)," # value # ")">;

// Here, the element type can be any integer or float type. But, note that only
// 32 bit integers are supported for the values.
class IsConstantValueOf<int value> : Constraint<CPred<
  "IsConstantValueOf($0," # value # ")">>;

def IsOnGpuDevicePred : CPred<"IsOnGpuDevice($0.getOwner())">;