byConstraint("belongs to platform org:platform:1.5")
                        selectedByRule("substitution from 'org:foo:[1.2,)' to 'org:foo:1.0'")
                        byConflictResolution("between versions 1.0 and 1.5")
                        module("org:bar:1.5") {
                            selectedByRule("substitution from 'org:bar:[1.2,)' to 'org:bar:1.0'")

			},
		},
		func(s *State, args ...string) (WaitFunc, error) {
			return nil, doCompare(s, false, args...)
		})
}

// Cmpenv is like Compare, but also performs environment substitutions
// on the contents of both arguments.
func Cmpenv() Cmd {
	return Command(
		CmdUsage{
			Args:    "[-q] file1 file2",
			Summary: "compare files for differences, with environment expansion",

/**
 * A [KaSubstitutor] which substitution logic can be represented as a [Map] from a [KaTypeParameterSymbol] to corresponding [KaType]
 * This is an implementation details and Analysis API clients should not depend on the fact if some [KaSubstitutor] is [KaMapBackedSubstitutor] or not.
 */
@KaAnalysisApiInternals
interface KaMapBackedSubstitutor : KaSubstitutor {
    /**

[[sec:dependency_substitution_rules]]
== Using dependency substitution rules

Dependency substitution rules work similarly to dependency resolve rules.
In fact, many capabilities of dependency resolve rules can be implemented with dependency substitution rules.
 They allow project and module dependencies to be transparently substituted with specified replacements.

        val substitutors = inheritancePath.map { (type, symbol) ->
            type.substitutorForSuperType(rootModuleSession, symbol)
        }
        return when (substitutors.size) {
            0 -> KaSubstitutor.Empty(token)
            else -> {
                val chained = substitutors.reduce { left, right -> left.chain(right) }

[[dependency_substitutions_with]]
==== Substitution.with replaced with Substitution.using

<<resolution_rules#sec:dependency_substitution_rules, Dependency substitutions>> using `with` method have been deprecated and are replaced with `using` method that also allows chaining.
For example, a dependency substitution rule `substitute(project(':a')).with(project(':b'))` should be replaced with

=== Using `CopySpec.filter()`

Transforming the content of files while they are being copied involves basic templating that uses token substitution, removal of lines of text, or even more complex filtering using a full-blown template engine.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file implements type parameter substitution.

package types2

import (
	"cmd/compile/internal/syntax"
)

type substMap map[*TypeParam]Type

// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
// If targs[i] is nil, tpars[i] is not substituted.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file implements type parameter substitution.

package types

import (
	"go/token"
)

type substMap map[*TypeParam]Type

// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
// If targs[i] is nil, tpars[i] is not substituted.
func makeSubstMap(tpars []*TypeParam, targs []Type) substMap {

	_ = atomic.LoadUint32(&x)             // ERROR "intrinsic substitution for LoadUint32"
	atomic.StoreUint32(&x, 1)             // ERROR "intrinsic substitution for StoreUint32"
	atomic.AddUint32(&x, 1)               // ERROR "intrinsic substitution for AddUint32"
	atomic.SwapUint32(&x, 1)              // ERROR "intrinsic substitution for SwapUint32"
	atomic.CompareAndSwapUint32(&x, 1, 2) // ERROR "intrinsic substitution for CompareAndSwapUint32"