kmp-verify-patterns

Files (1)

• SKILL.md

SKILL.md (first lines)

# KMP Verify Patterns

> After any code change, verify it compiles. Kotlin's type system catches most issues at compile time — if it compiles, it's likely correct. The cost of skipping verification is runtime crashes on the TV.

## Quick verification commands

### Type checking (fastest feedback)

```bash
# Compile shared-core for all targets (Kotlin multiplatform)
./gradlew :shared-core:compileKotlinAndroid

# Compile Android TV app (includes Compose compiler)
./gradlew :androidtv-app:compileDebugKotlin

# Full project compilation (use module-specific tasks to avoid ambiguity)
./gradlew :androidtv-app:compileDebugKotlin :shared-core:compileKotlinMetadata
```

**Use `:shared-core:compileKotlinAndroid`** after editing models/repositories — it's fast (10-20s) and catches type errors across the shared layer.

**Use `:androidtv-app:compileDebugKotlin`** after editing Compose screens — it runs the Compose compiler plugin which catches composable-specific errors.

### Lint / static analysis

```bash
# Android lint (catches common issues)
./gradlew :androidtv-app:lint

# Lint report location
# androidtv-app/build/reports/lint-results-debug.html
```

### Run tests

```bash
# Shared-core unit tests (contract tests for repositories)
./gradlew :shared-core:allTests

# Android TV instrumented tests (requires emulator)
./gradlew :androidtv-app:connectedDebugAndroidTest
```

## Common Compose compiler errors

### 1. `@Composable invocations can only happen from the context of a @Composable function`

**Cause:** Calling a composable from a non-composable (lambda, regular function).

**Fix:** Mark the containing function or lambda as `@Composable`:

```kotlin
// WRONG
val items = list.map { item -> Text(item.title) }

// RIGHT
list.forEach { item ->
    Text(item.title)  // Already inside a @Composable context
}
```

### 2. `Type mismatch: inferred type is Unit but ... was expected`

**Cause:** Compose content lambdas return Unit. If you're assigning the result of a composable call, that's wrong.

**Fix:** Composables are side-effects, not return values. Use state instead:

```kotlin
// WRONG
val text = Text("hello")  // Text returns Unit

// RIGHT
Text("hello")  // Just call it in the composition
```

### 3. `None of the following functions can be called with the arguments supplied`

**Cause:** Often the wrong `Surface` import. `androidx.tv.material3.Surface` vs `androidx.compose.material3.Surface` have different signatures.

**Fix:** Use TV Surface for focusable containers:

```kotlin
import androidx.tv.material3.Surface  // TV version with onClick
// NOT: import androidx.compose.material3.Surface
```

### 4. `Unresolved reference: ExperimentalTvMaterial3Api`

**Cause:** Missing TV Material dependency.

**Fix:** Ensure `build.gradle.kts` has:

```kotlin
implementation("androidx.tv:tv-material:1.0.0-alpha10")
```

And opt-in at the function level:

```kotlin
@OptIn(ExperimentalTvMaterial3Api::class)
@Composable
fun MyTVComponent() { ... }
```

### 5. `Modifier.focusRequester must be used with a FocusRequester that is remember'd`

**Cause:** Creating FocusRequester without `remember`.

**Fix:**
```kotlin
val focusRequester = remember { FocusRequester() }  // Always remember it
```

### 6. `kotlinCompilerExtensionVersion` mismatch

**Cause:** Compose compiler version doesn't match Kotlin version.

**Fix:** For Kotlin 1.9.24, use:
```kotlin

From giolaq/tv-build-harness, MIT-0.

More from giolaq/tv-build-harness