[riverpod_lint] Dependencies lint misses providers used in methods

[gaetschwartz]

Describe the bug
When using a provider inside a method that is being called in the build method, the provider usage is not detected.

To Reproduce
In this code, the linter doesn't detect the usage of eventsWithStreamedCompletionProvider:

@Riverpod(dependencies: [calendars])
class CalendarFeed extends _$CalendarFeed {
  @override
  Future<CalendarFeedState> build() async {
    final calendars = await ref.watch(calendarsProvider.future);
    final events = await listenToEvents();
    return CalendarFeedState(events: events, calendars: calendars);
  }

  Future<List<EventWithAsyncCompletion>> listenToEvents() async {
    final completer = Completer<List<EventWithAsyncCompletion>>();
    ref.listen(
		eventsWithStreamedCompletionProvider(),  
		/*function that completes the completer*/
	);
    final events = await completer.future;
    return events;
  }
}

but it does here:

@Riverpod(dependencies: [calendars])
class CalendarFeed extends _$CalendarFeed {
  @override
  Future<CalendarFeedState> build() async {
    final calendars = await ref.watch(calendarsProvider.future);
    final completer = Completer<List<EventWithAsyncCompletion>>();
    ref.listen(
		eventsWithStreamedCompletionProvider(),  
		/*function that completes the completer*/
	);
    final events = await completer.future;
    return CalendarFeedState(events: events, calendars: calendars);
  }
}

Expected behavior
It should detect it as well or at least give a way to add it manually to then dependencies without the linter complaining (forcing).

[rrousselGit]

It's not necessarily a bug

Only scoped providers need to be specified. Is eventsWithStreamedCompletionProvider() scoped?
If not, then the lint is fine.

I'd need to see eventsWithStreamedCompletionProvider() to be sure.

[gaetschwartz]

I'm not sure what you mean by scoped. But here is a rough implementation of it:

@Riverpod(dependencies: [eventsWith, profiles])
Stream<List<EventWithAsyncCompletion>> eventsWithStreamedCompletion(
  EventsWithStreamedCompletionRef ref, [
  EventProviderParam param = const EventProviderParam(),
]) async* {
  final f = await ref.watch(profilesProvider.future);
  final events = await ref.watch(eventsWithProvider(param).future);

  final cache = events
      .map((e) => EventWithAsyncCompletion(e, const AsyncLoading()))
      .toList();
  yield cache;
  yield* Stream.fromFutures(events.map(updateCache)).map((_) => cache);
}