* sense when there are many, possibly short-lived objects that need to be notified of a change. In such cases, subscriber management in the
 * message bus adds too much overhead.
 */
public abstract class KotlinModificationTrackerFactory : KotlinPlatformComponent {
    /**
     * Creates an out-of-block modification tracker which is incremented every time there is an out-of-block change in some source project

            return if (psi.valueParameters.isNotEmpty()) {
                psi.valueParameters.map { KaFe10PsiValueParameterSymbol(it, analysisContext) }
            } else {
                // There might be implicit 'it'
                descriptor?.valueParameters.orEmpty().map { KaFe10DescValueParameterSymbol(it, analysisContext) }
            }
        }

    override val hasStableParameterNames: Boolean

(SLWconst [s] (MOVWZreg w)) => (SLWconst [s] w)
(MOVWZreg w:(SLWconst u)) => w

// H - there are more combinations than these

(MOVHZreg y:(MOV(H|B)Zreg _)) => y // repeat
(MOVHZreg y:(MOVHBRload _ _)) => y

(MOVHreg y:(MOV(H|B)reg _)) => y // repeat

(MOV(H|HZ)reg y:(MOV(HZ|H)reg x)) => (MOV(H|HZ)reg x)

// W - there are more combinations than these

 *
 * Since this fallback is not suitable for symbols from binary libraries in Standalone mode, the symbol names provider absolutely needs to
 * work there. This functionality is covered by package scope tests.
 */
@OptIn(ExperimentalTopLevelDeclarationsGenerationApi::class)
internal object DeclarationsInPackageProvider {

! stderr 'GOPATH set to GOROOT'

# Cross-compiled binaries in cmd are installed to a ${GOOS}_${GOARCH} subdirectory,
# so we also want to try a copy there.
# (Note that the script engine's 'exec' engine already works around
# https://go.dev/issue/22315, so we don't have to do that explicitly in the
# 'check' program we use later.)

| 9  | `@implSpec`   | Adds a “Implementation Requirements” heading                                   | This is where the default implementation (or an overrideable implementation in a class) is specified                                                                                                               |

[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# There are no seed values, so 'go test' should finish quickly.
go test

# For the fuzzing phase, we reduce GOMAXPROCS to avoid consuming too many
# resources during the test. Ideally this would just free up resources to run
# other parallel tests more quickly, but unfortunately it is actually necessary
# in some 32-bit environments to prevent the fuzzing engine from running out of

    data object UnresolvedAssignmentLhs : ErrorReason // TODO: report candidate with rejection reasons
    data object UnresolvedAssignmentRhs : ErrorReason // TODO: resolution trace here, too?
    data object UnitAssignment : ErrorReason
    data object DanglingPureExpression : ErrorReason
}


class DefaultOperationGenerationId(override val ordinal: Int) : OperationGenerationId {
    companion object {

This is a platform that builds on the core and software platforms to add support for developing native software.

This platform provides specific support for Swift, C++ and C.

### Cross-cutting architecture modules

There are some additional cross-cutting architecture modules that aren't themselves platforms:

#### Enterprise integration

Provides cross-cutting integration with Gradle's commercial product.

#### IDE integration

     * As such, the call should probably be guarded with additional synchronization and memoization.
     *
     * Prefer [loadOrCreateValue] unless there is a special reason.
     */
    fun loadOrCreateOriginalValue(key: K, creator: () -> V): V {
        val originalValueCapture = AtomicReference<V>()
        val address = loadOrCreateAddress(key) {