import org.gradle.api.internal.artifacts.DefaultModuleIdentifier;

import javax.annotation.Nullable;
import java.util.Collections;

/**
 * A limited use, project dependency constraint mostly aimed at publishing
 * platforms.
 */
public class DefaultProjectDependencyConstraint extends AbstractDependencyConstraint {
    private final ProjectDependency projectDependency;
    private String reason;

        /**
         * The mutation of the attributes (other than coordinates) of a dependency constraint.
         * Theoretically these should be bundled under {@link MutationType#DEPENDENCIES}, but these mutations are not (yet)
         * prevented on resolved configurations.
         */
        DEPENDENCY_CONSTRAINT_ATTRIBUTES("dependency constraint attributes"),

        /**
         * The mutation of the artifacts of the configuration.

class IsBoolAttrEqual<string true_or_false> : Constraint<CPred<
  "$0.getValue() == "#true_or_false#"">>;

// Receives a composite DictionaryAttr as an argument and checks if one of the
// its attributes (with the name `attr_name`) is of type `attribute` and has
// the value `val`.
class IsCompositeAttribute<string attr_name, Attr attribute, string val>:
  Constraint<CPred<

class HasEqualElementSize<list<int> shape_1, list<int> shape_2> : Constraint<
  CPred<"quant::HasEqualElementSize($0, $1,"
  "llvm::ArrayRef<int>({" # !interleave(shape_1, ", ") # "}),"
  "llvm::ArrayRef<int>({" # !interleave(shape_2, ", ") # "}))">,
  "Checks if the given dimensions contain the same number of elements.">;

def ReshapableTo1DTensor : Constraint<
  CPred<"quant::ReshapableTo1DTensor($0.getType().cast<ShapedType>())">,

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

package p

// Constraint type inference should be independent of the
// ordering of the type parameter declarations. Try all
// permutations in the test case below.
// Permutations produced by https://go.dev/play/p/PHcZNGJTEBZ.

func f00[S1 ~[]E1, S2 ~[]E2, E1 ~byte, E2 ~byte](S1, S2) {}

        when:
        succeeds 'dependencyInsight', '--configuration', 'unlockedConf', '--dependency', 'foo'

        then:
        outputContains('org:foo:1.1')
        outputDoesNotContain('constraint')

    }

    def 'ignores the lockfile of a parent configuration when resolving an unlocked child configuration'() {
        mavenRepo.module('org', 'foo', '1.0').publish()

The `api` configuration should be used to declare constraints and dependencies which should be used when compiling against the platform, whereas the `runtime` configuration should be used to declare constraints or dependencies which are visible at runtime.

.Declaring API and runtime constraints
====
include::sample[dir="snippets/java-platform/quickstart/kotlin",files="build.gradle.kts[tags=constraints]"]

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

package p

func Ln[A A /* ERROR "cannot use a type parameter as constraint" */ ](p A) {

package p

type (
        C[T any] interface{~int; M() T}

        _ C[bool]
        _ comparable
        _ interface {~[]byte | ~string}

        // Alias type declarations may refer to "constraint" types
        // like ordinary type declarations.
        _ = C[bool]
        _ = comparable
        _ = interface {~[]byte | ~string}

// satisfied by SAME or VALID tensorflow padding.
def HasCustomPadding:
  Constraint<CPred<"GetAvgPoolOpPadAttr($_builder, (*$0.begin()).getDefiningOp<mhlo::CompositeOp>()) == $_builder.getStringAttr(\"CUSTOM\")">>;

// Returns true if the provided padding in the composite op can be satisfied 
// by SAME or VALID tensorflow padding.
def HasSameOrValidPadding: Constraint<Neg<HasCustomPadding.predicate>>;

// See the function doc in the header file.