type Serializer interface {
	runtime.Serializer
	recognizer.RecognizingDecoder
}

var _ Serializer = &serializer{}

type options struct {
	strict bool
}

type Option func(*options)

func Strict(s bool) Option {
	return func(opts *options) {
		opts.strict = s
	}
}

type serializer struct {
	metaFactory metaFactory
	creater     runtime.ObjectCreater
	typer       runtime.ObjectTyper

    }

    private String displayNameFor(String preferred, String required, String strict, List<String> rejects, branch = null) {
        new DefaultImmutableVersionConstraint(preferred, required, strict, rejects, branch).displayName
    }

        d.group == 'org.foo'
        d.name == 'bar'
        d.versionConstraint.requiredVersion == strict
        d.versionConstraint.strictVersion == strict
        d.versionConstraint.preferredVersion == preferred

        where:
        notation          | strict       | preferred
        '1.0!!'           | '1.0'        | ""
        '[1.0, 2.0]!!'    | '[1.0, 2.0]' | ""

public interface KaSubtypingComponentMixIn : KaSessionMixIn {
    public fun KaType.isEqualTo(other: KaType): Boolean =
        withValidityAssertion { analysisSession.subtypingComponent.isEqualTo(this, other, KaSubtypingErrorTypePolicy.STRICT) }

    public fun KaType.isEqualTo(other: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean =
        withValidityAssertion { analysisSession.subtypingComponent.isEqualTo(this, other, errorTypePolicy) }

// not a valid textual representation of an ETag.
func Parse(s string) (ETag, error) {
	const strict = false
	return parse(s, strict)
}

// parse parse s as an S3 ETag, returning the result.
// It operates in one of two modes:
//   - strict
//   - non-strict
//
// In strict mode, parse only accepts ETags that
// are AWS S3 compatible. In particular, an AWS

 */
package org.gradle.integtests.resolve.strict

import org.gradle.integtests.fixtures.GradleMetadataResolveRunner
import org.gradle.integtests.fixtures.RequiredFeature
import org.gradle.integtests.resolve.AbstractModuleDependencyResolveTest

class StrictVersionConstraintsFeatureInteractionIntegrationTest extends AbstractModuleDependencyResolveTest {
    def "can turn constraint into strict constraint by using a component metadata rule"() {

            analysisFlags = mapOf(
                JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState(
                    Jsr305Settings(ReportLevel.STRICT, ReportLevel.STRICT)
                ) { ReportLevel.STRICT },
            )
        )
    )

    put(JVMConfigurationKeys.SAM_CONVERSIONS, JvmClosureGenerationScheme.CLASS)
    put(JVMConfigurationKeys.PARAMETERS_METADATA, true)

====

[[sec:strict-version-consequences]]
=== Consequences of using strict versions

Using a strict version must be carefully considered, in particular by library authors.
As the _producer_, a strict version will effectively behave like a _force_: the version declaration takes precedence over whatever is found in the transitive dependency graph.

// A poset edge. The zero value is the null/empty edge.
// Packs target node index (31 bits) and strict flag (1 bit).
type posetEdge uint32

func newedge(t uint32, strict bool) posetEdge {
	s := uint32(0)
	if strict {
		s = 1
	}
	return posetEdge(t<<1 | s)
}
func (e posetEdge) Target() uint32 { return uint32(e) >> 1 }
func (e posetEdge) Strict() bool   { return uint32(e)&1 != 0 }
func (e posetEdge) String() string {

    go run ./cmd/gotemplate <hack/golangci.yaml.in >"${out}" "$@"
}

# Regenerate.
generate hack/golangci.yaml Base=1
generate hack/golangci-strict.yaml Strict=1