falconGitHub

avoid-passing-bloc-to-bloc

Path
lint/suspicious/avoid-passing-bloc-to-bloc
Default
Off, opt in
Origin
Falcon
Domain
bloc
Rule
109 of 512
bloc

Rejects direct Bloc and Cubit arguments to other blocs.

Invalid

example.dartdart
import 'support.dart';
import 'package:bloc/bloc.dart' as b;

typedef ConsumerAlias = Consumer;

class ConsumerCubit extends b.Cubit<int> {
  ConsumerCubit(Object dependency) : super(0);
}

void dependencies(Counter counter, Consumer consumer, b.Cubit<int> cubit) {
  Consumer(counter);
  new Consumer(counter);
  Consumer.named(dependency: cubit);
  ChildConsumer(counter);
  ConsumerAlias(counter);
  consumer.accept(counter);
  Consumer(Counter());
  ConsumerCubit(counter);
  consumer..accept(counter);
}

class ImplicitConsumer extends b.Cubit<int> {
  ImplicitConsumer() : super(0);
  void accept(Object dependency) {}
  void dependencies(Counter counter) {
    accept(counter);
    this.accept(counter);
  }
}

class InheritedConsumer extends ImplicitConsumer {
  void inherited(Counter counter) {
    accept(counter);
  }
}
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
10void dependencies(Counter counter, Consumer consumer, b.Cubit<int> cubit) {
11 Consumer(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
11 Consumer(counter);
12 new Consumer(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
12 new Consumer(counter);
13 Consumer.named(dependency: cubit);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
13 Consumer.named(dependency: cubit);
14 ChildConsumer(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
14 ChildConsumer(counter);
15 ConsumerAlias(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
15 ConsumerAlias(counter);
16 consumer.accept(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
16 consumer.accept(counter);
17 Consumer(Counter());
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
17 Consumer(Counter());
18 ConsumerCubit(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
18 ConsumerCubit(counter);
19 consumer..accept(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
25 void dependencies(Counter counter) {
26 accept(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
26 accept(counter);
27 this.accept(counter);
Avoid coupling blocs by passing a Bloc or Cubit to another bloc.
32 void inherited(Counter counter) {
33 accept(counter);

Valid

example.dartdart
import 'support.dart' as real;

class Bloc<E, S> {}
class Cubit<S> {}
class LocalBloc extends Bloc<Object, int> {
  LocalBloc(Object dependency);
}

class LookupConsumer extends real.Consumer {
  LookupConsumer() : super(0);
  static LookupConsumer of(real.Counter counter) => LookupConsumer();
}

void boundaries(real.Counter counter, real.Consumer consumer, dynamic unknown) {
  real.Consumer(real.Repository(0));
  real.Repository(counter);
  real.View(counter);
  real.Consumer(Cubit<int>());
  real.Consumer(Bloc<Object, int>());
  real.Consumer(unknown);
  LocalBloc(counter);
  consumer.accept(1);
  consumer..accept(1);
  LookupConsumer.of(counter);
  final Consumer = (Object dependency) => real.Repository(dependency);
  Consumer(counter);
}

void accept(Object value) {}

class ShadowedConsumer extends real.Consumer {
  ShadowedConsumer() : super(0);
  void localVariable(real.Counter counter) {
    final accept = (Object value) {};
    accept(counter);
  }
  void localFunction(real.Counter counter) {
    void accept(Object value) {}
    accept(counter);
  }
  void parameter(real.Counter counter, void Function(Object) accept) {
    accept(counter);
  }
  void libraryFunction(real.Counter counter) {
    accept(counter);
  }
  static void helper(Object value) {}
  void staticFunction(real.Counter counter) {
    helper(counter);
  }
}

Configure avoid-passing-bloc-to-bloc

Set its severity in falcon.json. See the configuration guide.

falcon.jsonjson
{
  "linter": {
    "rules": {
      "suspicious": {
        "avoid-passing-bloc-to-bloc": "error"
      }
    }
  }
}

Or silence one occurrence with a suppression comment; the reason is required.

example.dartdart
// falcon-ignore lint/suspicious/avoid-passing-bloc-to-bloc: <reason>