import org.jetbrains.kotlin.analysis.api.symbols.KaConstructorSymbol
import org.jetbrains.kotlin.name.Name

/**
 * A scope inside which use-site type-parameters of callable declarations may be substituted. Such declarations are represented as [KaCallableSignature].
 *
 * @see org.jetbrains.kotlin.analysis.api.components.KaScopeProviderMixIn.getTypeScope
 * @see KaCallableSignature
 */

            buildFile << """
                apply plugin: 'java-library'
            """
        }
    }

    def "EclipseProject model has closed project dependencies substituted in composite"() {
        setup:
        def workspace = eclipseWorkspace([project("buildA", buildA),
                                          project("buildB", buildB),

                new LockOutOfDateException("Did not resolve '" + forcedModule.getDisplayName() + "' which has been forced / substituted to a different version: '" + entry.getValue() + "'")));
        }
        return completedFailures;
    }

if [[ -n "$(which grealpath)" ]] &&  [[ -n "$(which gstat)" ]]; then
  alias realpath=grealpath
  alias stat=gstat
  # By default, aliases are only expanded in interactive shells, which means
  # that they are not substituted for their corresponding commands in shell
  # scripts. By setting "expand_aliases", we enable alias expansion in
  # non-interactive shells as well.
  shopt -s expand_aliases
else

        failures.size() == 1
        failures.each {
            assert it.problem instanceof LockOutOfDateException
            assert it.problem.message.contains("Did not resolve 'org:foo:1.1' which has been forced / substituted to a different version: '1.0'")
        }
    }

    def 'invokes locking provider on writeLocks with visited modules'() {
        given:
        def identifier = newId(mid, '1.1')

	r1, r2 rune
	want   rune
}{
	{0xd800, 0xdc00, 0x10000},
	{0xd800, 0xdc01, 0x10001},
	{0xd808, 0xdf45, 0x12345},
	{0xdbff, 0xdfff, 0x10ffff},
	{0xd800, 'a', 0xfffd}, // illegal, replacement rune substituted
}

func TestDecodeRune(t *testing.T) {
	for i, tt := range decodeRuneTests {
		got := DecodeRune(tt.r1, tt.r2)
		if got != tt.want {

func (t Tag) IsRoot() bool {
	if t.full != nil {
		return t.full.IsRoot()
	}
	return t.language == _und
}

// Parent returns the CLDR parent of t. In CLDR, missing fields in data for a
// specific language are substituted with fields from the parent language.
// The parent for a language may change for newer versions of CLDR.
func (t Tag) Parent() Tag {
	if t.full != nil {
		return Make(t.full.Parent())
	}

    override fun substitute(substitutor: KaSubstitutor): KaFunctionLikeSignature<S> = withValidityAssertion {
        KaFe10FunctionLikeSignature(
            symbol,
            substitutor.substitute(returnType),
            receiverType?.let { substitutor.substitute(it) },
            valueParameters.map { valueParameter ->

    override fun <S : KaFunctionLikeSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaFunctionLikeSignature<S> {
        if (substitutor is KaSubstitutor.Empty) return asSignature(symbol)
        return asSignature(symbol).substitute(substitutor)
    }

    override fun <S : KaVariableLikeSymbol> substitute(symbol: S, substitutor: KaSubstitutor): KaVariableLikeSignature<S> {
        if (substitutor is KaSubstitutor.Empty) return asSignature(symbol)

    override fun substitute(substitutor: KaSubstitutor): KaFirVariableLikeSignature<S> = withValidityAssertion {
        if (substitutor is KaSubstitutor.Empty) return@withValidityAssertion this
        require(substitutor is AbstractKaFirSubstitutor<*>)

        KaFirVariableLikeSubstitutorBasedSignature(token, firSymbol, firSymbolBuilder, substitutor.substitutor)
    }
}