equalTo("file 'displayNameOf(scriptFile)' has changed")
        )
    }

    @Test
    fun `build input file has been removed`() {
        val inputFile = File("input.txt")
        // no need to match a missing file hash, as long it is changed from the original one
        val missingFileHash = TestHashCodes.hashCodeFrom(2)
        val originalFileHash = TestHashCodes.hashCodeFrom(1)
        assertThat(

            val param =
                if (arg is FunctionArgument.Named) {
                    findParameterByName(arg.name) ?: return null
                    // TODO return a named argument that does not match any parameter
                } else parameters[argIndex]

            if (param in bindingMap) {
                // TODO: report arg conflict
                return@bindFunctionParametersToArguments null

                if (this !is CallableMemberDescriptor || dispatchReceiverParameter != null) {
                    // Non-static open callables in final class are counted as final (to match FIR)
                    return Modality.FINAL
                }
            }
        }

        return this.modality
    }

internal fun ConstantValue<*>.toKtConstantValue(): KaConstantValue {

    return ((this as? KtQualifiedExpression)?.selectorExpression ?: this) as? KtSimpleNameExpression?
}

/**
 * Helper abstraction to navigate through qualified FIR elements - we have to match [ClassId] and PSI qualifier pair
 * to correctly reason about long qualifiers.
 */
private sealed interface TypeQualifier {
    val referencedClassId: ClassId

    /**

            for (part in packageParts.reversed()) {
                if (javaDir?.name == part) {
                    javaDir = javaDir.parent
                } else {
                    // Error(ish): file package does not match file path.
                    // This could happen if, e.g., src/my/pkg/MyTest.java has package `test.pkg`.
                    // It is just best practice, not enforced by language spec.

// on the matching side
//  - the type, aux, and auxint fields must match if they are specified.
//  - the first occurrence of a variable defines that variable.  Subsequent
//    uses must match (be == to) the first use.
//  - v is defined to be the value matched.
//  - an additional conditional can be provided after the match pattern with "&&".
// on the generated side

(Rsh8x8          <t> x y) => (ISEL [2] (SRAD     <t> (MOVBreg  x) y) (SRADconst <t>  (MOVBreg x) [7]) (CMPconst [0] (ANDconst [0x00F8] y)))

// Catch bounded shifts in situations like foo<<uint(shift&63) which might not be caught by the prove pass.
(CMP(U|WU)const [d] (ANDconst z [c])) && uint64(d) > uint64(c) => (FlagLT)

(ORN x (MOVDconst [-1])) => x

	&& isSameCall(sym, "runtime.memmove")
	&& s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1
	&& isInlinableMemmove(dst, src, sz, config)
	&& clobber(s1, s2, s3, call)
	=> (Move [sz] dst src mem)

// Match post-lowering calls, register version.
(SelectN [0] call:(CALLstatic {sym} dst src (MOVDconst [sz]) mem))
	&& sz >= 0
	&& isSameCall(sym, "runtime.memmove")
	&& call.Uses == 1

[exec:patch] cp go.mod go.mod.tidyResult
[exec:patch] cp go.sum go.sum.tidyResult

# Compare output of -diff to running tidy.
# Apply the patch from -diff
[exec:patch] cp go.mod.orig go.mod
[exec:patch] cp go.sum.orig go.sum
[exec:patch] ! go mod tidy -diff
[exec:patch] cp stdout diff.patch
[exec:patch] exec patch -p1 -i diff.patch
[exec:patch] go mod tidy -diff
[exec:patch] ! stdout .
[exec:patch] cmp go.mod go.mod.tidyResult

        return withValidityAssertion {
            try {
                analysisSession.compilerFacility.compile(file, configuration, target, allowedErrorFilter)
            } catch (e: ProcessCanceledException) {
                throw e
            } catch (e: Throwable) {
                throw KaCodeCompilationException(e)
            }
        }
    }
}

public typealias KtCompilerFacilityMixIn = KaCompilerFacilityMixIn