Metro

https://zacsweers.github.io/metro/1.0.0
Admin
Metro is a compile-time dependency injection framework for Kotlin that unifies best features from...
Tokens:140,417
Snippets:1,909
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Recommended Installation of MetroViewModelFactory

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel/dev.zacsweers.metrox.viewmodel/-metro-view-model-factory/index.html

Subclass MetroViewModelFactory and contribute an injected binding. Override provider maps as needed. This example shows installation for Compose, Activity, and Fragment.

```kotlin
@DependencyGraph(AppScope::class)
interface MyGraph : ViewModelGraph

@Inject
@ContributesBinding(AppScope::class)
@SingleIn(AppScope::class)
class MyViewModelFactory(
  override val viewModelProviders: Map<KClass<out ViewModel>, () -> ViewModel>,
  override val assistedFactoryProviders: Map<KClass<out ViewModel>, () -> ViewModelAssistedFactory>,
  override val manualAssistedFactoryProviders: Map<KClass<out ManualViewModelAssistedFactory>, () -> ManualViewModelAssistedFactory>,
): MetroViewModelFactory()

// Compose installation
@Composable
class AppEntry(metroVmf: MetroViewModelFactory) {
  CompositionLocalProvider(LocalMetroViewModelFactory provides metroVmf) {
    App(...)
  }
}

// Activity installation
@Inject
class ExampleActivity(private val viewModelFactory: MyViewModelFactory) : ComponentActivity() {
  override val defaultViewModelProviderFactory: ViewModelProvider.Factory
    get() = viewModelFactory
}

// Fragment installation
@Inject
class ExampleFragment(private val viewModelFactory: MyViewModelFactory) : Fragment() {
  override val defaultViewModelProviderFactory: ViewModelProvider.Factory
    get() = viewModelFactory
}
```

--------------------------------

### Dynamic Graph Creation Example

Source: https://zacsweers.github.io/metro/1.0.0/changelog

Demonstrates how to create and use dynamic graphs by passing binding containers to `createDynamicGraph` for testing or runtime graph manipulation.

```kotlin
import org.junit.Test
import kotlin.test.assertEquals

@DependencyGraph
interface AppGraph {
  val message: String

  @Provides fun provideMessage(): String = "real"
}

class AppTest {
  val testGraph = createDynamicGraph<AppGraph>(FakeBindings)

  @Test
  fun test() {
    assertEquals("fake", testGraph.message)
  }

  @BindingContainer
  object FakeBindings {
    @Provides fun provideMessage(): String = "fake"
  }

}
```

--------------------------------

### Basic Assisted Injection Setup

Source: https://zacsweers.github.io/metro/1.0.0/designdoc.html

For types requiring dynamic dependencies at instantiation, use assisted injection. Annotate the constructor with @Inject, assisted parameters with @Assisted, and define an @AssistedFactory interface.

```kotlin
@Inject
class HttpClient(
@Assisted val timeout: Duration,
val cache: Cache
) {
@AssistedFactory
fun interface Factory {
fun create(timeout: Duration): HttpClient
}
}
```

--------------------------------

### NetworkGraph Example

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-dependency-graph/-factory/index.html

Example of a NetworkGraph interface exposing an accessor for HttpClient, which can be used as a binding in the consuming AppGraph.

```kotlin
interface NetworkGraph {
  val httpClient: HttpClient
}
```

--------------------------------

### Convenience Helper Functions for Interop in Gradle

Source: https://zacsweers.github.io/metro/1.0.0/interop

Utilize convenience helper functions in the Gradle extension for common interop configurations with Dagger, Kotlin-Inject, and Guice. This simplifies setup for integrating with these frameworks.

```gradle
metro {
  interop {
    // Dagger
    includeDagger()
    includeAnvilForDagger()

    // kotlin-inject
    includeKotlinInject()
    includeAnvilForKotlinInject()

    // Guice
    includeGuice()
  }
}

```

--------------------------------

### Provide HttpClient for AppScope

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-for-scope/index.html

Example of providing an HttpClient bound to the AppScope using the @ForScope annotation.

```kotlin
@DependencyGraph(AppScope::class)
interface AppGraph {
  @Provides
  @ForScope(AppScope::class)
  fun provideHttpClient(): HttpClient = ...
}
```

--------------------------------

### Metro Missing Binding Error Example

Source: https://zacsweers.github.io/metro/1.0.0/changelog

Illustrates a typical error message from Metro when a binding cannot be found, providing hints for resolution.

```text
[Metro/MissingBinding] Cannot find an @Inject constructor or @Provides-annotated function/property for: FooImpl

    FooImpl is injected at
        [AppGraph] Bindings.bind: FooImpl
    Base is requested at
        [AppGraph] AppGraph.base

(Hint)
'FooImpl' doesn't appear to be visible to this compilation. This can happen when a binding references a type from an 'implementation' dependency that isn't exposed to the consuming graph's module.
Possible fixes:
- Mark the module containing 'FooImpl' as an 'api' dependency in the module that defines 'Bindings' (which is requesting it).
- Add the module containing 'FooImpl' as an explicit dependency to the module that defines 'AppGraph'.

```

--------------------------------

### Defining a Graph Extension

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-graph-extension/index.html

This example shows how to define a graph extension for a specific scope (LoggedInScope) and how to contribute its factory to a broader scope (AppScope).

```APIDOC
## Graph Extension Definition

### Description
Defines a graph extension that aggregates dependencies within the `LoggedInScope`. The factory for this extension is contributed to the `AppScope`.

### Interface Definition
```kotlin
@GraphExtension(LoggedInScope::class)
interface LoggedInGraph {
  val userRepository: UserRepository

  @ContributesTo(AppScope::class)
  @GraphExtension.Factory
  interface Factory {
    fun createLoggedInGraph(): LoggedInGraph
  }
}
```

### Usage Example
```kotlin
// Obtain a LoggedInGraph instance from an AppGraph instance
val loggedInGraph = appGraph.createLoggedInGraph()
```
```

--------------------------------

### Implement MetroAppComponentProviders in MetroApp

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-application/app-component-providers.html

Demonstrates how to implement MetroAppComponentProviders in a custom Application class using a lazy-initialized app graph. This setup is required for dependency injection factories like MetroAppComponentFactory.

```kotlin
class MetroApp : Application(), MetroApplication {
  /** Holder reference for the app graph for [MetroAppComponentFactory]. */
  val appGraph by lazy { createGraph<AppGraph>() }

  override val appComponentProviders: MetroAppComponentProviders
    get() = appGraph
}

@DependencyGraph
interface AppGraph : MetroAppComponentProviders {
  // ...
}
```

--------------------------------

### Create Dynamic Graph Factory Example

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/create-dynamic-graph-factory.html

Demonstrates creating a dynamic graph factory for testing purposes. The `createGraphFactory` function is used with a generic type `AppGraph` and a `FakeBindings` object to override default bindings.

```kotlin
@DependencyGraph
interface AppGraph {
  val message: String

  @Provides fun provideMessage(): String = "real"
}

class AppTest {
  val testGraph = createGraphFactory<AppGraph>(FakeBindings)

  @Test
  fun test() {
    assertEquals("fake", testGraph.message)
  }

  @BindingContainer
  object FakeBindings {
    @Provides fun provideMessage(): String = "fake"
  }
}
```

--------------------------------

### Constructor Injection Example

Source: https://zacsweers.github.io/metro/1.0.0/designdoc.html

Use constructor injection for most types. Annotate either the class itself (if it has exactly one primary constructor) or a specific constructor with @Inject.

```kotlin
@Inject
class ClassInjected

class SpecificConstructorInjection(val text: String) {
@Inject constructor(value: Int) : this(value.toString())
}
```

--------------------------------

### Install Metro Gradle Plugin

Source: https://zacsweers.github.io/metro/1.0.0/quickstart

Apply the Metro Gradle plugin in your project's build script to add runtime dependencies and configure the compiler plugin.

```gradle
plugins {
  kotlin("multiplatform") // or jvm, android, etc
  id("dev.zacsweers.metro") version "1.0.0"
}

```

--------------------------------

### Define AppGraph with Switching Providers

Source: https://zacsweers.github.io/metro/1.0.0/dependency-graphs

Define your dependency graph interface with `@DependencyGraph` and specify providers using `@Provides` and `@SingleIn`. This example shows how to provide a String and an Int, with the Int depending on the String.

```kotlin
// The graph
@DependencyGraph(AppScope::class)
interface AppGraph {
  @Provides @SingleIn(AppScope::class) fun provideString(): String = "Hello, world!"
  @Provides @SingleIn(AppScope::class) fun provideInt(string: String): Int = string.length

  val stringLength: Int
}
```

--------------------------------

### Configure User-Defined Annotations in Gradle

Source: https://zacsweers.github.io/metro/1.0.0/interop

Configure custom annotations for interop with other frameworks like Dagger via the Gradle extension. This example shows how to add Dagger's @Assisted annotation.

```gradle
metro {
  interop {
    assisted.add("dagger/assisted/Assisted")
  }
}

```

--------------------------------

### getPluginArtifact

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle/-metro-gradle-subplugin/index.html

Gets the artifact information for the plugin.

```APIDOC
## getPluginArtifact

### Description
Retrieves the artifact details for this Gradle plugin.

### Returns
SubpluginArtifact - The artifact information for the plugin.
```

--------------------------------

### enableSwitchingProviders

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle/-metro-plugin-extension/enable-switching-providers.html

Enables switching providers for deferred class loading. This reduces graph initialization time by deferring bindings' class init until it's actually requested. This is analogous to Dagger's `fastInit` option. You should only use this if you've benchmarked it and measured a meaningful difference, as it comes with the same tradeoffs (always holding a graph instance ref, etc.). Disabled by default.

```APIDOC
## Property enableSwitchingProviders

### Description
Enables switching providers for deferred class loading. This reduces graph initialization time by deferring bindings' class init until it's actually requested. This is analogous to Dagger's `fastInit` option. You should only use this if you've benchmarked it and measured a meaningful difference, as it comes with the same tradeoffs (always holding a graph instance ref, etc.). Disabled by default.

### Type
Property<Boolean>
```

--------------------------------

### invoke

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-provider/index.html

Abstract operator function to invoke the provider and get an instance of type T.

```APIDOC
expect abstract operator fun invoke(): T

actual abstract operator fun invoke(): T

actual abstract operator override fun invoke(): T

actual abstract operator override fun invoke(): T

actual abstract operator override fun invoke(): T
```

--------------------------------

### instantiateServiceCompat

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/instantiate-service-compat.html

Instantiates a service compat. This function takes a ClassLoader, a class name, and an optional Intent as parameters and returns a Service instance.

```APIDOC
## instantiateServiceCompat

### Description
Instantiates a service compat.

### Signature
open override fun instantiateServiceCompat( cl: ClassLoader, className: String, intent: Intent?): Service
```

--------------------------------

### instantiateApplicationCompat

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/instantiate-application-compat.html

Instantiates an ApplicationCompat given a ClassLoader and the Application's class name.

```APIDOC
## instantiateApplicationCompat

### Description
Instantiates an ApplicationCompat using the provided ClassLoader and the fully qualified class name of the Application.

### Method Signature
`open override fun instantiateApplicationCompat(cl: ClassLoader, className: String): Application`

### Parameters
#### Path Parameters
- **cl** (ClassLoader) - The ClassLoader to use for loading the Application class.
- **className** (String) - The fully qualified name of the Application class to instantiate.

### Returns
An instance of `Application`.
```

--------------------------------

### metroViewModel

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel-compose/dev.zacsweers.metrox.viewmodel/metro-view-model.html

Retrieves a Metro-injected ViewModel using the LocalMetroViewModelFactory. This is the primary way to get ViewModels in your composables.

```APIDOC
## metroViewModel

### Description
Retrieves a Metro-injected ViewModel using the LocalMetroViewModelFactory.

### Signature
```kotlin
@Composable
inline fun <VM : ViewModel> metroViewModel(
    viewModelStoreOwner: ViewModelStoreOwner = requireViewModelStoreOwner(),
    key: String? = null
): VM
```

### Parameters
- **viewModelStoreOwner**: The `ViewModelStoreOwner` to use for retrieving the ViewModel. Defaults to the current `requireViewModelStoreOwner()`.
- **key**: An optional key to distinguish ViewModels if multiple instances of the same type are needed.
```

--------------------------------

### instantiateProviderCompat

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/index.html

Instantiates a ContentProvider using the provided ClassLoader and class name, with compatibility.

```APIDOC
## instantiateProviderCompat

### Description
Instantiates a ContentProvider using the provided ClassLoader and class name, with compatibility.

### Function Signature
open override fun instantiateProviderCompat( cl: ClassLoader,  className: String): ContentProvider
```

--------------------------------

### Graph Aggregation Example

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-dependency-graph/index.html

Demonstrates how a @DependencyGraph can automatically aggregate contributions from other annotated types within the same scope.

```kotlin
@DependencyGraph(AppScope::class)
interface AppGraph

@ContributesTo(AppScope::class)
interface HttpClientProvider {
  val httpClient: HttpClient
}

@ContributesBinding(AppScope::class)
@Inject
class RealHttpClient(...) : HttpClient

// Results in generated code like...
@DependencyGraph(AppScope::class)
interface AppGraph : HttpClientProvider {
  /* fake */override val RealHttpClient.bind: HttpClient
}
```

--------------------------------

### assistedMetroViewModel (Standard)

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel-compose/dev.zacsweers.metrox.viewmodel/assisted-metro-view-model.html

Retrieves a Metro-injected ViewModel using the LocalMetroViewModelFactory. This is the standard way to get a ViewModel that has been injected with Metro dependencies.

```APIDOC
## assistedMetroViewModel<VM : ViewModel>

### Description
Retrieves a Metro-injected ViewModel using the LocalMetroViewModelFactory.

### Parameters
- `viewModelStoreOwner`: ViewModelStoreOwner - The ViewModelStoreOwner to use for retrieving the ViewModel. Defaults to `requireViewModelStoreOwner()`.
- `key`: String? - An optional key to distinguish ViewModels.
- `extras`: CreationExtras - Additional creation extras to be used when creating the ViewModel. Defaults to `CreationExtras.Empty` or `viewModelStoreOwner.defaultViewModelCreationExtras` if available.
```

--------------------------------

### instantiateApplication

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/index.html

Instantiates an Application using the provided ClassLoader and class name.

```APIDOC
## instantiateApplication

### Description
Instantiates an Application using the provided ClassLoader and class name.

### Function Signature
fun instantiateApplication( cl: @NonNull ClassLoader,  className: @NonNull String): @NonNull Application
```

--------------------------------

### Get Binding Metadata

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle.analysis/-binding-graph/get-binding.html

This function retrieves binding metadata by its key. If no binding is found for the given key, it returns null.

```APIDOC
## getBinding

### Description
Get binding metadata by key, or null if not found.

### Signature
`fun getBinding(key: String): BindingMetadata?`
```

--------------------------------

### instantiateProviderCompat

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/instantiate-provider-compat.html

Instantiates a ContentProvider using the provided ClassLoader and class name.

```APIDOC
## instantiateProviderCompat

### Description
Instantiates a `ContentProvider` using the provided `ClassLoader` and class name.

### Signature
`open override fun instantiateProviderCompat(cl: ClassLoader, className: String): ContentProvider`

### Parameters
#### Path Parameters
- **cl** (`ClassLoader`) - The ClassLoader to use for loading the provider.
- **className** (`String`) - The fully qualified name of the ContentProvider class.

### Returns
A `ContentProvider` instance.
```

--------------------------------

### Create and Use Manual ViewModel Factory

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel/dev.zacsweers.metrox.viewmodel/-manual-view-model-assisted-factory/index.html

Obtain a manual factory using `createManuallyAssistedFactory` and then create a ViewModel with custom parameters.

```kotlin
val factory = metroViewModelFactory.createManuallyAssistedFactory(MyFactory::class)
val viewModel = factory().create("param1", 42)
```

--------------------------------

### Top-Level Function Injection

Source: https://zacsweers.github.io/metro/1.0.0/injection-types

Inject dependencies directly into top-level functions, useful for composable functions and applications starting from `main`.

```kotlin
@Inject
fun App(message: String) {
  // ...
}
```

--------------------------------

### instantiateProvider

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/index.html

Instantiates a ContentProvider using the provided ClassLoader and class name.

```APIDOC
## instantiateProvider

### Description
Instantiates a ContentProvider using the provided ClassLoader and class name.

### Function Signature
fun instantiateProvider( cl: @NonNull ClassLoader,  className: @NonNull String): @NonNull ContentProvider
```

--------------------------------

### Contribute Binding Container with @ContributesTo

Source: https://zacsweers.github.io/metro/1.0.0/aggregation

Use `@ContributesTo` to add binding containers to scopes. This example shows contributing `NetworkBindings` to `AppScope`.

```kotlin
@ContributesTo(AppScope::class)
@BindingContainer
object NetworkBindings {
  @Provides fun provideHttpClient(): HttpClient = HttpClient()
}

@DependencyGraph(AppScope::class)
interface AppGraph {
  val httpClient: HttpClient
}
```

--------------------------------

### instantiateService

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/index.html

Instantiates a Service using the provided ClassLoader, class name, and Intent.

```APIDOC
## instantiateService

### Description
Instantiates a Service using the provided ClassLoader, class name, and Intent.

### Function Signature
fun instantiateService( cl: @NonNull ClassLoader,  className: @NonNull String,  intent: @Nullable Intent?): @NonNull Service
```

--------------------------------

### create

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel/dev.zacsweers.metrox.viewmodel/-view-model-assisted-factory/index.html

Creates a ViewModel instance with assisted injection.

```APIDOC
## create

### Description
Creates a ViewModel instance with assisted injection using the provided CreationExtras.

### Method
abstract fun create(extras: CreationExtras): ViewModel

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (ViewModel)
- **ViewModel** (ViewModel) - The created ViewModel instance.

#### Response Example
None
```

--------------------------------

### Publish to Local Maven Repo

Source: https://zacsweers.github.io/metro/1.0.0/contributing

Use this command to publish the project to a local Maven repository. Specify the desired version for the local build.

```bash
./metrow publish --local --version 1.0.0-LOCAL01 # whatever version you want

```

--------------------------------

### Example Usage of @Multibinds

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-multibinds/index.html

Demonstrates how to use the @Multibinds annotation on abstract graph members to declare multibindings for sets and maps, including the `allowEmpty` option.

```APIDOC
## Example Usage of @Multibinds

### Description
This example shows how to declare various types of multibindings using `@Multibinds` within a dependency graph.

### Code Example
```kotlin
@DependencyGraph interface MyGraph {
  @Multibinds(allowEmpty = true) fun aSet(): Set<Foo>
  @Multibinds(allowEmpty = true) @MyQualifier val aQualifiedSet: Set<Foo>
  @Multibinds(allowEmpty = true) fun aMap(): Map<String, Foo>
  @Multibinds(allowEmpty = true) @MyQualifier val aQualifiedMap: Map<String, Foo>

  @Provides
  fun usesMultibindings(set: Set<Foo>, @MyQualifier map: Map<String, Foo>): Any {
    return …
  }
}
```
```

--------------------------------

### Configure Local Clone with Gradle

Source: https://zacsweers.github.io/metro/1.0.0/contributing

Add this to your consuming project's `settings.gradle.kts` to enable Gradle's included build feature. This allows testing against a local Metro clone without publishing.

```kotlin
// Check for local Metro clone path via gradle property or system property
val metroLocalClone: String? = providers.gradleProperty("metro.localClone").orNull
  ?: System.getProperty("metro.localClone")

if (metroLocalClone != null) {
  includeBuild(metroLocalClone) {
    dependencySubstitution {
      substitute(module("dev.zacsweers.metro:compiler")).using(project(":compiler"))
      substitute(module("dev.zacsweers.metro:runtime")).using(project(":runtime"))
      substitute(module("dev.zacsweers.metro:gradle-plugin")).using(project(":gradle-plugin"))
      substitute(module("dev.zacsweers.metro:interop-dagger")).using(project(":interop-dagger"))
      // Add any other substitutions you need (interop-guice, metrox-*, etc)
    }
  }
}


```

--------------------------------

### Create Dynamic Graph with Fake Bindings

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/create-dynamic-graph.html

Demonstrates creating a dynamic graph for testing purposes by providing fake bindings. This is useful for isolating components and verifying their behavior with specific dependencies.

```kotlin
@DependencyGraph
interface AppGraph {
  val message: String

  @Provides fun provideMessage(): String = "real"
}

class AppTest {
  val testGraph = createGraph<AppGraph>(FakeBindings)

  @Test
  fun test() {
    assertEquals("fake", testGraph.message)
  }

  @BindingContainer
  object FakeBindings {
    @Provides fun provideMessage(): String = "fake"
  }
}
```

--------------------------------

### Create Dynamic Graph with Fake Bindings

Source: https://zacsweers.github.io/metro/1.0.0/dependency-graphs

Demonstrates creating a dynamic graph with fake bindings for testing purposes. Ensure all binding containers are non-local, canonical classes.

```kotlin
@DependencyGraph
interface AppGraph {
  val message: String

  @Provides fun provideMessage(): String = "real"
}

class AppTest {
  val testGraph = createDynamicGraph<AppGraph>(FakeBindings)

  @Test
  fun test() {
    assertEquals("fake", testGraph.message)
  }

  @BindingContainer
  object FakeBindings {
    @Provides fun provideMessage(): String = "fake"
  }
}

```

--------------------------------

### Default Binding Annotation Example

Source: https://zacsweers.github.io/metro/1.0.0/changelog

Illustrates the use of the `@DefaultBinding` annotation to set a default binding on supertypes of contributed classes. This is particularly useful for generic base classes.

```kotlin
@DefaultBinding<BaseFactory<*>> 
interface BaseFactory<T : BaseFactory<T>>

@ContributesIntoSet(AppScope::class) // now implicitly contributed as BaseFactory<*>
@Inject
class HomeFactory(...) : BaseFactory<HomeFactory>
```

--------------------------------

### Kotlin Graph Dependency Cycle Error Reporting

Source: https://zacsweers.github.io/metro/1.0.0/validation-and-error-reporting

This example demonstrates a graph dependency cycle error detected by Metro. It highlights the requested component and its creation path.

```kotlin
ExampleGraph.kt:6:1 [Metro/GraphDependencyCycle] Dependency graph dependency cycle detected! The below graph depends on itself.
    test.CharSequenceGraph is requested at
        [test.CharSequenceGraph] test.CharSequenceGraph.Factory.create()


```

--------------------------------

### Basic Provider Usage

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-provides/index.html

Demonstrates how to use the @Provides annotation on a property to provide a String instance to the dependency graph.

```APIDOC
## @Provides Property

### Description
Marks a property that provides an instance of a given type to the dependency graph. The provider is lazily evaluated.

### Usage
```kotlin
@DependencyGraph
interface AppGraph : NetworkProviders {
  @Provides val string: String get() = "Hello, world!"
}

interface NetworkProviders {
  @Provides fun provideHttpClient(): HttpClient = HttpClient()
}
```
```

--------------------------------

### Kotlin Dependency Cycle Error Reporting

Source: https://zacsweers.github.io/metro/1.0.0/validation-and-error-reporting

This example shows a dependency cycle error reported by Metro. It details the injected types and the graph path leading to the cycle.

```kotlin
ExampleGraph.kt:6:1 [Metro/DependencyCycle] Found a dependency cycle:
    kotlin.Int is injected at
        [test.ExampleGraph] test.ExampleGraph.provideString(..., int)
    kotlin.String is injected at
        [test.ExampleGraph] test.ExampleGraph.provideDouble(..., string)
    kotlin.Double is injected at
        [test.ExampleGraph] test.ExampleGraph.provideInt(..., double)
    kotlin.Int is injected at
        [test.ExampleGraph] test.ExampleGraph.provideString(..., int)


```

--------------------------------

### instantiateActivityCompat

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/index.html

Instantiates an Activity using the provided ClassLoader, class name, and Intent, with compatibility.

```APIDOC
## instantiateActivityCompat

### Description
Instantiates an Activity using the provided ClassLoader, class name, and Intent, with compatibility.

### Function Signature
open override fun instantiateActivityCompat( cl: ClassLoader,  className: String,  intent: Intent?): Activity
```

--------------------------------

### create

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel/dev.zacsweers.metrox.viewmodel/-metro-view-model-factory/create.html

Overrides the create method to provide ViewModel instances.

```APIDOC
## create

### Description
Overrides the create method to provide ViewModel instances.

### Signature
override fun <T : ViewModel> create(modelClass: KClass<T>, extras: CreationExtras): T
```

--------------------------------

### Define Singleton Scope with SingleIn

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-single-in/index.html

Use SingleIn to declare that a provided dependency is a singleton within the specified scope. This example shows how to provide an HttpClient as a singleton in AppScope.

```kotlin
@DependencyGraph(AppScope::class)
interface AppGraph {
  @SingleIn(AppScope::class)
  @Provides
  fun provideHttpClient(): HttpClient = HttpClient()
}
```

--------------------------------

### instantiateActivity

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/index.html

Instantiates an Activity using the provided ClassLoader, class name, and Intent.

```APIDOC
## instantiateActivity

### Description
Instantiates an Activity using the provided ClassLoader, class name, and Intent.

### Function Signature
fun instantiateActivity( cl: @NonNull ClassLoader,  className: @NonNull String,  intent: @Nullable Intent?): @NonNull Activity
```

--------------------------------

### Annotated Class with AssistedFactory

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-assisted-factory/index.html

Example of an @AssistedInject class with an automatically generated @AssistedFactory nested interface. The factory method signature must match the assisted parameters of the constructor.

```kotlin
@AssistedInject
class HttpClient(
  @Assisted timeoutDuration: Duration,
  cache: Cache,
) {
  // Generated by Metro
  @AssistedFactory
  fun interface Factory {
    fun create(timeoutDuration: Duration): HttpClient
  }
}
```

--------------------------------

### Improved Member Injection Error Trace

Source: https://zacsweers.github.io/metro/1.0.0/changelog

This example shows the improved error reporting for member injection, now specifying the injected type and the exact member injection callable declaration.

```java
dev.zacsweers.metro.MembersInjector<test.FeatureScreen> is requested at
    [test.FeatureGraph] test.FeatureGraph#inject()

```

```java
test.Dependency is requested at
    [test.FeatureGraph] test.FeatureScreen.dependency
test.FeatureScreen is injected at
    [test.FeatureGraph] test.FeatureGraph#inject()

```

--------------------------------

### Using Function Types as Providers

Source: https://zacsweers.github.io/metro/1.0.0/changelog

Demonstrates how to use Kotlin's `() -> T` higher-order functions as providers when `enableFunctionProviders` is enabled. This allows for more idiomatic provider definitions.

```kotlin
@DependencyGraph
interface AppGraph {
  val stringProvider: () -> String

  @Provides fun provideString(): String = "Hello, world!"
}

fun main() {
  val provider = createGraph<AppGraph>().stringProvider
  println(provider())
}
```

--------------------------------

### Declaring and Using DefaultBinding

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-default-binding/index.html

Use @DefaultBinding to declare a default binding type for an interface. Subtypes can then implicitly use this default, even with multiple supertypes, as shown in the MyFactory example.

```kotlin
@DefaultBinding<ThingFactory<*>> 
interface ThingFactory<T : Thing> {
  fun create(): T
}

// Implicitly binds as ThingFactory<*> even though it has multiple supertypes
@ContributesBinding(AppScope::class)
@Inject
class MyFactory : ThingFactory<MyThing>, AnotherInterface
```

--------------------------------

### enableSwitchingProviders

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle/-metro-plugin-extension/index.html

Enables switching providers for deferred class loading. This reduces graph initialization time by deferring bindings' class init until it's actually requested.

```APIDOC
## Property enableSwitchingProviders

### Description
Enables switching providers for deferred class loading. This reduces graph initialization time by deferring bindings' class init until it's actually requested.

### Type
Property<Boolean>
```

--------------------------------

### ViewModel with Assisted Factory

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel/dev.zacsweers.metrox.viewmodel/-view-model-assisted-factory/index.html

Example of a ViewModel using @AssistedInject and defining an @AssistedFactory interface that implements ViewModelAssistedFactory. The factory's create method is overridden to extract parameters from CreationExtras.

```kotlin
@AssistedInject
class DetailsViewModel(@Assisted val id: String) : ViewModel() {
  // ...

  @AssistedFactory
  @ViewModelAssistedFactoryKey(DetailsViewModel::class)
  @ContributesIntoMap(AppScope::class)
  fun interface Factory : ViewModelAssistedFactory {
    override fun create(extras: CreationExtras): DetailsViewModel {
      return create(extras.get<String>(KEY_ID))
    }

    fun create(@Assisted id: String): DetailsViewModel
  }
}
```

--------------------------------

### instantiateActivityCompat

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/instantiate-activity-compat.html

Instantiates an ActivityCompat using the provided ClassLoader, class name, and optional Intent.

```APIDOC
## instantiateActivityCompat

### Description
Instantiates an ActivityCompat using the provided ClassLoader, class name, and optional Intent.

### Signature
open override fun instantiateActivityCompat( cl: ClassLoader, className: String, intent: Intent?): Activity
```

--------------------------------

### Enable Guice Interop

Source: https://zacsweers.github.io/metro/1.0.0/interop

Enable this option to integrate with Guice annotations and runtime types. Note that the companion Gradle plugin automatically adds the `dev.zacsweers.metro:interop-guice` dependency.

```kotlin
metro {
  interop {
    includeGuice()
  }
}
```

--------------------------------

### Conditional Injection with Optional Bindings

Source: https://zacsweers.github.io/metro/1.0.0/bindings

Combine optional bindings with nullable types for conditional injection, especially across different source sets. The example shows injecting an optional repository.

```kotlin
// in src/main
@Inject
class ExampleUseCase(
  val optionalRepository: OptionalRepository? = null
)

interface OptionalRepository

// If you want to expose it to your graph
@ContributesTo(AppScope::class)
interface OptionalRepositoryProvider {
  @OptionalDependency
  val optionalRepository: OptionalRepository? get() = null
}
```

```kotlin
// Dependency of the src/debug source set
@Inject
@ContributesBinding(AppScope::class) // Standard binding
// Add a nullable binding so it can satisfy the nullable injection
// in the consuming project when present on the classpath
@ContributesBinding(AppScope::class, binding = binding<OptionalRepository?>())
class OptionalRepositoryImpl : OptionalRepository
```

--------------------------------

### Obtain LoggedInGraph Instance

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-graph-extension/index.html

Demonstrates how to obtain an instance of a contributed graph extension from the main application graph, either with or without IDE support.

```kotlin
// Using the asContribution() intrinsic
val loggedInGraph = appGraph.asContribution<LoggedInGraph.Factory>().createLoggedInGraph()

// Or if you have IDE support enabled
val loggedInGraph = appGraph.createLoggedInGraph()
```

--------------------------------

### Run Gradle Build with Local Clone

Source: https://zacsweers.github.io/metro/1.0.0/contributing

Execute your Gradle build with the `-Pmetro.localClone` property pointing to your local Metro repository path. This is useful for debugging and testing changes.

```bash
./gradlew compileKotlin -Pmetro.localClone=/path/to/metro

```

--------------------------------

### Dependency Graph with Multiple Scopes

Source: https://zacsweers.github.io/metro/1.0.0/designdoc.html

Example of how to define a dependency graph that supports multiple scopes, including an application scope and a debug-specific internal scope. This is useful for managing different build variants.

```kotlin
@DependencyGraph(
scope = AppScope::class,
additionalScopes = [...] 
)
```

--------------------------------

### Graph with `@Provides` Input Parameter

Source: https://zacsweers.github.io/metro/1.0.0/dependency-graphs

Illustrates a dependency graph that accepts a runtime input via a factory method's `@Provides` parameter. This is analogous to Dagger's `@BindsInstance`.

```kotlin
@DependencyGraph
interface AppGraph {
  val message: String

  @DependencyGraph.Factory
  fun interface Factory {
    fun create(@Provides message: String): AppGraph
  }
}
```

--------------------------------

### Instantiating a Simple Graph

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-dependency-graph/index.html

For simple graphs without explicit creators, use createGraph to instantiate them.

```kotlin
val graph = createGraph<AppGraph>()
```

--------------------------------

### Type Alias Diagnostic Example

Source: https://zacsweers.github.io/metro/1.0.0/changelog

Demonstrates how Metro reports diagnostics when types are aliases, including the aliased type in the error message for better clarity. This helps identify issues where a bound type is the same as the alias.

```kotlin
typealias UserId = String
interface Bindings {
  // error: Binds receiver type `kotlin.String` is the same type and qualifier as the bound type `UserId (typealias to kotlin.String)`.
  @Binds fun String.bind(): UserId
}

```

--------------------------------

### create

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-viewmodel/dev.zacsweers.metrox.viewmodel/-metro-view-model-factory/index.html

Creates a ViewModel instance. It first checks the assistedFactoryProviders map for a provider, and if not found, it falls back to the viewModelProviders map.

```APIDOC
## Functions
create
Link copied to clipboard
override fun <T : ViewModel> create( modelClass: KClass<T>,  extras: CreationExtras): T
```

--------------------------------

### Task Configuration and Execution

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle.analysis/-analyze-graph-task/index.html

Methods for configuring task actions, dependencies, and execution conditions.

```APIDOC
## Task Configuration and Execution

### `acceptServiceReferences(serviceReferences: Set<ServiceReferenceSpec?>?)`
Accepts service references for the task.

### `appendParallelSafeAction(action: Action<in Task?>?)`
Appends a parallel-safe action to the task.

### `configure(closure: Closure<*>?): Task?`
Configures the task using a closure.

### `doFirst(action: Closure<*>?): Task?`
Adds an action to be executed before the task's main execution.

### `doFirst(action: Action<in Task?>?): Task?`
Adds an action to be executed before the task's main execution.

### `doFirst(actionName: String?, action: Action<in Task?>?): Task?`
Adds a named action to be executed before the task's main execution.

### `doLast(action: Closure<*>?): Task?`
Adds an action to be executed after the task's main execution.

### `doLast(action: Action<in Task?>?): Task?`
Adds an action to be executed after the task's main execution.

### `doLast(actionName: String?, action: Action<in Task?>?): Task?`
Adds a named action to be executed after the task's main execution.

### `doNotTrackState(reasonNotToTrackState: String?)`
Disables state tracking for the task with a given reason.

### `doNotTrackStateIf(reason: String?, spec: Spec<in TaskInternal?>?)`
Disables state tracking for the task if the given specification is met.

### `hasTaskActions(): Boolean`
Checks if the task has any associated actions.

### `onlyIf(onlyIfClosure: Closure<*>?): Task?`
Defines a condition under which the task should run using a closure.

### `onlyIf(spec: Spec<in Task?>?): Task?`
Defines a condition under which the task should run using a specification.

### `onlyIf(onlyIfReason: String?, spec: Spec<in Task?>?): Task?`
Defines a conditional execution for the task with a reason.

### `prependParallelSafeAction(action: Action<in Task?>?)`
Prepends a parallel-safe action to the task.

### `restoreOnlyIf(onlyIf: Spec<in TaskInternal?>?)`
Restores the conditional execution specification for the task.

### `restoreTaskActions(taskActions: List<InputChangesAwareTaskAction?>?)`
Restores the task actions.

### `setOnlyIf(onlyIfClosure: Closure<*>?): Task?`
Sets the condition for task execution using a closure.

### `setOnlyIf(spec: Spec<in Task?>?): Task?`
Sets the condition for task execution using a specification.

### `setOnlyIf(onlyIfReason: String?, spec: Spec<in Task?>?): Task?`
Sets the conditional execution for the task with a reason.
```

--------------------------------

### Using SingleIn Scope with AppScope

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-scope/index.html

This example demonstrates how to use the `SingleIn` scope annotation with `AppScope` to ensure a single instance of `HttpClient` within the `AppGraph`. The `AppGraph` itself is annotated with `AppScope` to declare its supported scope.

```kotlin
@SingleIn(AppScope::class)
@Inject
class HttpClient(...)

@DependencyGraph(AppScope::class)
interface AppGraph {
  val httpClient: HttpClient
}
```

--------------------------------

### apply

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle/-metro-gradle-subplugin/index.html

Applies the plugin to the target Project.

```APIDOC
## apply

### Description
Applies the plugin's logic to the given Gradle Project.

### Parameters
- **target** (Project) - The Project to which the plugin is applied.
```

--------------------------------

### Parameter Type Mismatch Error in Native Builds

Source: https://zacsweers.github.io/metro/1.0.0/changelog

This example demonstrates a parameter type mismatch error encountered during native builds, related to Kotlin compiler bug KT-83427. It clarifies the source and mirror parameter types.

```kotlin
e: Mirror/create function parameter type mismatch:
  - Source:         com.example.navigation.NavigationProviders.navigationSerializationModule
  - Mirror param:   @com.example.app.navigation.NavigationSerializers kotlin.collections.Set<kotlinx.serialization.modules.SerializersModule>
  - create() param: kotlin.collections.Set<kotlinx.serialization.modules.SerializersModule>

This is a known bug in the Kotlin compiler, follow https://github.com/ZacSweers/metro/issues/1556

```

--------------------------------

### Graph Factory Generation Scenarios

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-dependency-graph/-factory/index.html

Visual representation of the scenarios Metro automatically handles for generating graph factory implementations.

```text
                     ┌────────────────────┐
               ┌─────┤Has a graph factory?├──┐
               │     └────────────────────┘  │
               ▼                             ▼
               No                           Yes
               │                             │
               │                             │
     ┌─────────▼─────────────┐       ┌───────▼───────────┐
     │  Generate an empty    │       │Is it an interface?│
     │ operator fun invoke() │       └─┬──────────┬──────┘
     │to the companion object│         │          ▼
     └───────────────────────┘         │          No
                                       │          │
                                       │  ┌───────▼───────────┐
                   Yes◄────────────────┘  │ Is there already  │
                    │                     │a companion object?│
           ┌────────▼──────────┐          └┬────────────┬─────┘
           │ Is there already  │           │            │
           │a companion object?│           ▼            ▼
           └┬─────────────────┬┘          Yes           No───┐
            ▼                 ▼            │                 │
           Yes                No           │         ┌───────▼────┐
            │                 │            ├─────────┤Generate one│
┌───────────▼─────────┐       │            │         └────────────┘
│Generate a matching  │       │          ┌─▼───────────────────────────┐
│operator fun invoke()│       │          │Generate a factory() function│
│function into it     │       │          │    into it                  │
└─────────────────────┘       │          └─────────────────────────────┘
                              │
                              │
             ┌────────────────▼───────┐
             │Generate one and make it│
             │implement the factory   │
             │interface               │
             └────────────────────────┘
```

--------------------------------

### Declaring Multibindings with @Multibinds

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-multibinds/index.html

Use @Multibinds to declare abstract graph members returning sets or maps. Set `allowEmpty = true` to permit empty multibindings. This example shows declarations for sets and maps, both with and without qualifiers.

```kotlin
@DependencyGraph interface MyGraph {
  @Multibinds(allowEmpty = true) fun aSet(): Set<Foo>
  @Multibinds(allowEmpty = true) @MyQualifier val aQualifiedSet: Set<Foo>
  @Multibinds(allowEmpty = true) fun aMap(): Map<String, Foo>
  @Multibinds(allowEmpty = true) @MyQualifier val aQualifiedMap: Map<String, Foo>

  @Provides
  fun usesMultibindings(set: Set<Foo>, @MyQualifier map: Map<String, Foo>): Any {
    return …
  }
}
```

--------------------------------

### Initialize Interop Handler

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle/-metro-plugin-extension/interop.html

Instantiate the `InteropHandler` for the Metro plugin, passing the source object. This is part of the interop configuration process.

```kotlin
val interop: MetroPluginExtension.InteropHandler(source)
```

--------------------------------

### Provider and Lazy Dependencies

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-inject/index.html

Demonstrates how to inject dependencies wrapped in provider functions `() -> T` or `Lazy<T>`.

```APIDOC
## Provider functions and Lazy

### Description
Injected dependency parameter types may be wrapped in a function (`() -> T`) or Lazy and Metro will enforce these contracts in its generated code. Provider is also supported as an equivalent alternative to `() -> T`, but is considered legacy use and a warning by default.

### Example
```kotlin
@Inject
class HttpClient(
  // A Cache instance will be lazily provided each time the function is invoked
  providedCache: () -> Cache,
  // A lazily-computed Cache instance will be created whenever Lazy.value is called
  lazyCache: Lazy<Cache>,
)
```

**Note:** The contract of Lazy is that it will _only_ be lazy to the scope of the class. To make a dependency a singleton within a given graph, you must use a Scope like SingleIn.
```

--------------------------------

### Graph Extension with Arguments

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-graph-extension/index.html

Demonstrates how to define a graph extension factory that accepts arguments, such as a user ID, during creation.

```APIDOC
## Graph Extension with Arguments

### Description
Defines a graph extension factory that accepts a `userId` string as a provider argument during its creation.

### Factory Definition
```kotlin
@ContributesTo(AppScope::class)
@GraphExtension.Factory
interface Factory {
  fun create(@Provides userId: String): LoggedInGraph
}
```

### Generated Implementation
```kotlin
// Generated in IR
@DependencyGraph(LoggedInScope::class)
class LoggedInGraphImpl(
  parent: AppGraph,
  @Provides userId: String
): LoggedInGraph {
  // ... implementation details ...
}
```

### Generated Factory Method
```kotlin
// Generated in IR
override fun create(userId: String): LoggedInGraph {
  return LoggedInGraphImpl(this, userId)
}
```
```

--------------------------------

### Instantiating a Graph with a Factory

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-dependency-graph/index.html

When a graph has creators, use createGraphFactory to obtain a factory and then create graph instances.

```kotlin
val graph = createGraphFactory<AppGraph.Factory().create("hello!")
```

--------------------------------

### Task Configuration and Actions

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle.analysis/-generate-graph-html-task/index.html

Functions for configuring task execution, adding actions, and managing task state.

```APIDOC
## Functions

### acceptServiceReferences

```kotlin
open fun acceptServiceReferences(serviceReferences: Set<ServiceReferenceSpec?>?)
```

### appendParallelSafeAction

```kotlin
open fun appendParallelSafeAction(action: Action<in Task?>?)
```

### doFirst

```kotlin
open fun doFirst(action: Closure<*>?)
open fun doFirst(action: Action<in Task?>?)
open fun doFirst(actionName: String?, action: Action<in Task?>?)
```

### doLast

```kotlin
open fun doLast(action: Closure<*>?)
open fun doLast(action: Action<in Task?>?)
open fun doLast(actionName: String?, action: Action<in Task?>?)
```

### doNotTrackState

```kotlin
open fun doNotTrackState(reasonNotToTrackState: String?)
```

### doNotTrackStateIf

```kotlin
open fun doNotTrackStateIf(reason: String?, spec: Spec<in TaskInternal?>?)
```

### hasTaskActions

```kotlin
open fun hasTaskActions(): Boolean
```

### notCompatibleWithConfigurationCache

```kotlin
open fun notCompatibleWithConfigurationCache(reason: String?)
```

### onlyIf

```kotlin
open fun onlyIf(onlyIfClosure: Closure<*>?)
open fun onlyIf(spec: Spec<in Task?>?)
open fun onlyIf(onlyIfReason: String?, spec: Spec<in Task?>?)
```

### prependParallelSafeAction

```kotlin
open fun prependParallelSafeAction(action: Action<in Task?>?)
```

### restoreOnlyIf

```kotlin
open fun restoreOnlyIf(onlyIf: Spec<in TaskInternal?>?)
```

### restoreTaskActions

```kotlin
open fun restoreTaskActions(taskActions: List<InputChangesAwareTaskAction?>?)
```

### setOnlyIf

```kotlin
open fun setOnlyIf(onlyIfClosure: Closure<*>?)
open fun setOnlyIf(spec: Spec<in Task?>?)
open fun setOnlyIf(onlyIfReason: String?, spec: Spec<in Task?>?)
```
```

--------------------------------

### Provider with Dependencies

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-provides/index.html

Shows how a provider method can declare dependencies as parameters, which will be automatically injected by the Metro compiler.

```APIDOC
## Provider with Dependencies

### Description
Provider callables can declare dependencies as parameters. These dependencies are automatically managed and injected by the Metro compiler.

### Usage
```kotlin
interface NetworkProviders {
  @Provides fun provideHttpClient(cache: Cache): HttpClient = HttpClient(cache)
}
```
```

--------------------------------

### supportedHintContributionPlatforms

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle/-metro-plugin-extension/index.html

Sets the target Kotlin platforms for which contribution hints will be generated.

```APIDOC
## Property: supportedHintContributionPlatforms

### Description
Configures the specific Kotlin platforms for which the Metro plugin will generate contribution hints. If this property is not set, the plugin computes defaults based on platform and Kotlin version compatibility.

### Type
SetProperty<KotlinPlatformType>
```

--------------------------------

### Implement MetroAppComponentProviders

Source: https://zacsweers.github.io/metro/1.0.0/metrox-android

Make your AppGraph interface implement MetroAppComponentProviders to provide necessary components.

```kotlin
@DependencyGraph(AppScope::class)
interface AppGraph : MetroAppComponentProviders
```

--------------------------------

### asGuiceProvider

Source: https://zacsweers.github.io/metro/1.0.0/api/interop-guice/dev.zacsweers.metro.interop.guice/index.html

Converts a Metro Provider into a Guice Provider.

```APIDOC
## asGuiceProvider

### Description
Converts a Metro MetroProvider into a Guice GuiceProvider.

### Signature
```kotlin
fun <T : Any> Provider<T>.asGuiceProvider(): Provider<T>
```
```

--------------------------------

### Publish Local Maven Artifacts with Metro CLI

Source: https://zacsweers.github.io/metro/1.0.0/contributing

Use `./metrow publish --local --version x.y.z` to publish artifacts to your local Maven repository with a specified version. Replace `x.y.z` with your desired version.

```bash
./metrow publish --local --version x.y.z
```

--------------------------------

### Provider with Wrapped Dependencies

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-provides/index.html

Illustrates how dependencies can be wrapped in Provider or Lazy, and Metro will manage them during injection.

```APIDOC
## Provider with Wrapped Dependencies

### Description
Dependencies passed to providers can be wrapped in `Provider` or `Lazy`. Metro automatically handles their management during injection.

### Usage
```kotlin
interface NetworkProviders {
  @Provides fun provideHttpClient(lazyCache: Lazy<Cache>): HttpClient = HttpClient(lazyCache)
}
```
```

--------------------------------

### BindingGraph.from

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle.analysis/-binding-graph/-companion/from.html

Builds a BindingGraph from GraphMetadata.

```APIDOC
## from

### Description
Build a BindingGraph from GraphMetadata.

### Signature
fun from(metadata: GraphMetadata): BindingGraph(source)
```

--------------------------------

### Enable Metro Tracing in Gradle DSL

Source: https://zacsweers.github.io/metro/1.0.0/performance

Configure Metro to output Perfetto trace files for performance analysis. Note that file option inputs are not tracked, so use `--rerun` for accurate tracing.

```gradle
metro {
  traceDestination.set(layout.buildDirectory.dir("metro/trace"))
}

```

--------------------------------

### Assisted Inject with Named Parameters

Source: https://zacsweers.github.io/metro/1.0.0/designdoc.html

Demonstrates using named parameters for assisted injection, which can preserve annotation sites for generated code and extension sites for interface extensions. This approach is considered for DI frameworks.

```kotlin
class MyClass @AssistedInject constructor(
@Assisted("p1") p1: String,
@Assisted("p2") p2: Int,
) {
@AssistedInject.Factory
interface MyFactory
}
```

--------------------------------

### instantiateClassLoader

Source: https://zacsweers.github.io/metro/1.0.0/api/metrox-android/dev.zacsweers.metrox.android/-metro-app-component-factory/index.html

Instantiates a ClassLoader with the provided ClassLoader and ApplicationInfo.

```APIDOC
## instantiateClassLoader

### Description
Instantiates a ClassLoader with the provided ClassLoader and ApplicationInfo.

### Function Signature
open fun instantiateClassLoader( cl: ClassLoader,  aInfo: ApplicationInfo): ClassLoader
```

--------------------------------

### DependencyGraph.Factory with @Provides

Source: https://zacsweers.github.io/metro/1.0.0/api/runtime/dev.zacsweers.metro/-provides/index.html

Illustrates how the @Provides annotation can be used on parameters of a DependencyGraph factory to provide instances to the graph.

```APIDOC
## DependencyGraph.Factory with @Provides

### Description
When a parameter on a `DependencyGraph.Factory` is annotated with `@Provides`, that instance is added as a binding to the graph. This allows clients of the factory to pass their own instances, which can then be injected within the graph.

### Usage
```kotlin
@DependencyGraph.Factory
interface Factory {
  fun newMyGraph(
    @Provides foo: Foo,
    @Provides @Blue bar: Bar
  ): MyGraph
}
```
```

--------------------------------

### dependencies

Source: https://zacsweers.github.io/metro/1.0.0/api/gradle-plugin/dev.zacsweers.metro.gradle.analysis/-assisted-target-metadata/dependencies.html

Retrieves the actual dependencies of the target, not wrapped in a Provider.

```APIDOC
## dependencies

### Description
The target's actual dependencies (not Provider-wrapped).

### Signature
```kotlin
val dependencies: List<DependencyMetadata>
```
```
Tokens:
Raw