readProviderElement<State> method

@override ProviderElementBase<State> readProviderElement<State>(ProviderBase<State> provider)

Reads the state of a provider, potentially creating it in the process.

It may throw if the provider requested threw when it was built.

Do not use this in production code. This is exposed only for testing and devtools, to be able to test if a provider has listeners or similar.

Implementation

@override
ProviderElementBase<State> readProviderElement<State>(
  ProviderBase<State> provider,
) {
  if (_disposed) {
    throw StateError(
      'Tried to read a provider from a ProviderContainer that was already disposed',
    );
  }

  final reader = _putIfAbsent(provider);

  assert(
    () {
      // Avoid having the assert trigger itself exponentially
      if (!_debugVerifyDependenciesAreRespectedEnabled) return true;

      try {
        _debugVerifyDependenciesAreRespectedEnabled = false;

        // Check that this containers doesn't have access to an overridden
        // dependency of the targeted provider
        final targetElement = reader.getElement();
        final visitedDependencies = <ProviderBase<Object?>>{};
        final queue = Queue<ProviderBase<Object?>>();
        targetElement.visitAncestors((e) => queue.add(e.origin));

        while (queue.isNotEmpty) {
          final dependency = queue.removeFirst();
          if (visitedDependencies.add(dependency)) {
            final dependencyElement =
                readProviderElement<Object?>(dependency);

            assert(
              targetElement.provider != targetElement.origin ||
                  dependencyElement ==
                      targetElement.container
                          .readProviderElement<Object?>(dependency),
              '''
Tried to read $provider from a place where one of its dependencies were overridden but the provider is not.

To fix this error, you can add $dependency (a) to the "dependencies" of $provider (b) such that we have:

```
final a = Provider(...);
final b = Provider((ref) => ref.watch(a), dependencies: [a]);
```
''',
            );

            dependencyElement.visitAncestors((e) => queue.add(e.origin));
          }
        }
      } finally {
        _debugVerifyDependenciesAreRespectedEnabled = true;
      }
      return true;
    }(),
    '',
  );

  return reader.getElement() as ProviderElementBase<State>;
}