Currently implementing this rule based on the test cases below; if anyone has input or disagreements on what should and shouldn't be linted let me know! Have taken heavy inspiration from this document on the topic of the use_build_context_synchronously rule design.

Good weather (Should not lint)

Synchronous emits

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  void loadData() {
      emit(5);
  }
}

Protecting inside an `isNotClosed` block inside async

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  Future<void> loadData() async {
    final data = await Future.value(42);
    if (!isClosed) {
      emit(data);
    }
  }
}

Guarding with an `isClosed => return;` statement inside async

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  Future<void> loadData() async {
    final data = await Future.value(42);
    if (isClosed) {
        return;
    }
    emit(data);
  }
}

Stupid guarding that could be written better

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  Future<void> loadData() async {
    final data = await Future.value(42);
    if (isClosed == false) {
        return;
    }
    emit(data);
  }
}

Bad weather path (Should lint)

Not guarding with `isClosed`

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  Future<void> loadData() async {
    final data = await Future.value(42);
  
    emit(data);
  }
}

Reintroducing asynchronosity after guarding

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  Future<void> loadData() async {
    int data = await Future.value(42);
    if (!isClosed) {
        data = await Future.value(52);
        emit(data);      
    }
  }
}

Irrelevant Guarding

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  Future<void> loadData() async {
    int data = await Future.value(42);
    if(!isClosed) {
        print('sike');
    }
    emit(data);
  }
}

Will not cover (too complex)

Complex if statements forcing us to figure out the result

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);
    
  Future<void> loadData() async {
    int data = await Future.value(42);
    if(!isClosed && state == 15) {
  	  emit(data);
    }
  }
}

Functions that resolve `isClosed`

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);

  bool isClosedCalculator() => isClosed;
    
  Future<void> loadData() async {
    int data = await Future.value(42);
    if(!isClosedCalculator()) {
  	  emit(data);
    }
  }
}

Comparing `isClosed` to variables

import 'package:flutter_bloc/flutter_bloc.dart';

class MyCubit extends Cubit<int> {
  MyCubit() : super(0);


  final bool x = true;
    
  Future<void> loadData() async {
    int data = await Future.value(42);
    if(isClosed == x) {
  	  return;
    }
    emit(data);
  }
}

Uh oh!

feat(bloc_lint): avoid_async_emit #4490

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions