DartのNull safetyについて調べる

void main() {
  var i = 42;
  i = null; // A value of type 'Null' can't be assigned to a variable of type 'int'.
}

void main() {
  int? nullable;
  nullable = null;
}

environment:
  sdk: '>=2.12.0 <3.0.0'

dart migrate

// Without null safety:
bool isEmpty(String string) => string.length == 0;

main() {
  isEmpty(null);
}

void main() {
  makeCoffee("coffee");
  makeCoffee("coffee", "dairy");
}

makeCoffee(String coffee, [String? dairy]) {
  if (dairy != null) {
    print('$coffee with $dairy');
  } else {
    print('Black $coffee');
  }
}

bad(String? maybeString) {
  print(maybeString.length);
}

main() {
  bad(null);
}

The property 'length' can't be unconditionally accessed because the receiver can be 'null'.

bad(String? maybeString) {
  print(maybeString.toString()); // null
  print(maybeString.hashCode); // 0
  print(maybeString == null); // true
}

main() {
  bad(null);
}

requireStringNotNull(String definitelyString) {
  print(definitelyString.length);
}

main() {
  String? maybeString = null; // Or not!
  requireStringNotNull(maybeString);
}

The argument type 'String?' can't be assigned to the parameter type 'String'.

requireStringNotObject(String definitelyString) {
  print(definitelyString.length);
}

main() {
  Object maybeString = 'it is';
  requireStringNotObject(maybeString);
}

The argument type 'Object' can't be assigned to the parameter type 'String'.

requireStringNotObject(String definitelyString) {
  print(definitelyString.length); // 5
}

main() {
  Object maybeString = 'it is';
  requireStringNotObject(maybeString as String);
}

List<int> filterEvens(List<int> ints) {
  return ints.where((n) => n.isEven);
}

main() {
  print(filterEvens([1, 2, 3]));
}

A value of type 'Iterable<int>' can't be returned from the function 'filterEvens' because it has a return type of 'List<int>'.

String missingReturn() {
  // No return.
}

The body might complete normally, causing 'null' to be returned, but the return type, 'String', is a potentially non-nullable type.

int topLevel;

class SomeClass {
  static int staticField;
}

The non-nullable variable 'topLevel' must be initialized.
The non-nullable variable 'staticField' must be initialized.

class SomeClass {
  int atDeclaration = 0;
  int initializingFormal;
  int initializationList;

  SomeClass(this.initializingFormal)
      : initializationList = 0;
}

class SomeClass {
  int uninitialized;
  SomeClass();
}

Non-nullable instance field 'uninitialized' must be initialized.

int tracingFibonacci(int n) {
  int result;
  if (n < 2) {
    result = n;
  } else {
    result = tracingFibonacci(n - 2) + tracingFibonacci(n - 1);
  }

  print(result);
  return result;
}

int tracingFibonacci(int n) {
  int result;
  if (n < 2) {
    result = n;
  }

  print(result);
  return result;
}

The non-nullable local variable 'result' must be assigned before it can be used.
The non-nullable local variable 'result' must be assigned before it can be used.

void myPrint([String message]) {
  print(message);
}

The parameter 'message' can't have a value of 'null' because of its type, but the implicit default value is 'null'.

bool isEmptyList(Object object) {
  if (object is List) {
    return object.isEmpty;
  } else {
    return false;
  }
}

bool isEmptyList(Object object) {
  if (object is! List) return false;
  return object.isEmpty;
}

void main() {
  print(isEmptyList([]));
}

void func(Object o) {
  for (var i = 0; i < 10; i += 1) {
    if (o is! List) {
      break;
    }
    print(o.isEmpty);
  }
}

Never wrongType(String type, Object value) {
  throw ArgumentError('Expected $type, but was ${value.runtimeType}.');
}

Never wrongType(String type, Object value) {}

The body might complete normally, causing 'null' to be returned, but the return type, 'Never', is a potentially non-nullable type.

class Point {
  final double x, y;

  bool operator ==(Object other) {
    if (other is! Point) wrongType('Point', other);
    return x == other.x && y == other.y;
  }

  // Constructor and hashCode...
}

int tracingFibonacci(int n) {
  final int result;
  if (n < 2) {
    result = n;
  } else {
    result = tracingFibonacci(n - 2) + tracingFibonacci(n - 1);
  }

  print(result);
  return result;
}

int tracingFibonacci(int n) {
  final int result;
  if (n < 2) {
    result = n;
  }

  print(result);
  return result;
}

The final variable 'result' can't be read because it's potentially unassigned at this point.

String makeCommand(String executable, [List<String>? arguments]) {
  var result = executable;
  if (arguments != null) {
    result += ' ' + arguments.join(' ');
  }
  return result;
}

String makeCommand(String executable, [List<String>? arguments]) {
  var result = executable;
  if (arguments == null) return result;
  return result + ' ' + arguments.join(' ');
}

String checkList(List<Object> list) {
  if (list?.isEmpty ?? false) {
    return 'Got nothing';
  }
  return 'Got something';
}

The receiver can't be null, so the null-aware operator '?.' is unnecessary.

void main() {
  String? notAString = null;
  print(notAString?.length);
}

void main() {
  String? notAString = null;
  print(notAString?.length.isEven);
}

receiver?..method();
receiver?[index];

void main() {
  final list = null as List<int>?;
  
  list?..add(1)
    ..add(2);
  
  print(list); // null
}

function?.call(arg1, arg2);

class HttpResponse {
  final int code;
  final String? error;

  HttpResponse.ok()
      : code = 200,
        error = null;
  HttpResponse.notFound()
      : code = 404,
        error = 'Not found';

  @override
  String toString() {
    if (code == 200) return 'OK';
    return 'ERROR $code ${error.toUpperCase()}';
  }
}

The method 'toUpperCase' can't be unconditionally invoked because the receiver can be 'null'.

return 'ERROR $code ${(error as String).toUpperCase()}';

return 'ERROR $code ${error!.toUpperCase()}';

class Coffee {
  String? _temperature;

  void heat() { _temperature = 'hot'; }
  void chill() { _temperature = 'iced'; }

  String serve() => _temperature! + ' coffee';
}

void main() {
  final coffee = Coffee();
  coffee.serve(); // Uncaught TypeError: Cannot read properties of null (reading '$add')Error: TypeError: Cannot read properties of null (reading '$add')
}

class Coffee {
  late String _temperature;

  void heat() { _temperature = 'hot'; }
  void chill() { _temperature = 'iced'; }

  String serve() => _temperature + ' coffee';
}

void main() {
  final coffee = Coffee();
  coffee.serve(); // Uncaught Error: LateInitializationError: Field '_temperature' has not been initialized.
}

class Weather {
  late int _temperature = _readThermometer();
}

class Weather {
  late int temperature = _readThermometer();
  
  int _readThermometer() {
    print("_readThermometer called");
    return 30;
  }
}

void main() {
  final weather = Weather();
  print("start");
  print(weather.temperature);
  print(weather.temperature);
}

start
_readThermometer called
30
30

class Coffee {
  late final String _temperature;

  void heat() { _temperature = 'hot'; }
  void chill() { _temperature = 'iced'; }

  String serve() => _temperature + ' coffee';
}

class Coffee {
  late final String _temperature;

  void heat() { _temperature = 'hot'; }
  void chill() { _temperature = 'iced'; }

  String serve() => _temperature + ' coffee';
}

void main() {
  final coffee = Coffee();
  
  coffee.heat();
  print(coffee.serve()); // hot coffee
  
  coffee.chill(); // Uncaught Error: LateInitializationError: Field '_temperature' has already been initialized.
  print(coffee.serve());
}

void main() {
  func(n: 1);
}

void func({required int n}) {
  print("n = $n"); // n = 1
}

abstract class Cup {
  String contents;
}

Non-nullable instance field 'contents' must be initialized.

abstract class Cup {
  abstract String contents;
}

class MyCup implements Cup {
  @override
  String contents = "Coffee";
}

abstract class Cup {
  String get contents;
  set contents(String str);
}

class Coffee {
  String? _temperature;

  void heat() { _temperature = 'hot'; }
  void chill() { _temperature = 'iced'; }

  void checkTemp() {
    if (_temperature != null) {
      print('Ready to serve ' + _temperature + '!');
    }
  }
}

class Coffee {
  String? _temperature;

  void heat() { _temperature = 'hot'; }
  void chill() { _temperature = 'iced'; }

  void checkTemp() {
    final temperature = _temperature;
    if (temperature != null) {
      print('Ready to serve ' + temperature + '!');
    }
  }
}

class Box<T> {
  final T object;
  Box(this.object);
}

main() {
  Box<String>('a string');
  Box<int?>(null);
}

class Box<T> {
  T? object;
  Box.empty();
  Box.full(this.object);

  T unbox() => object as T;
}

main() {
  var box = Box<int?>.full(null);
  print(box.unbox());
}

class Interval<T extends num> {
  T min, max;

  Interval(this.min, this.max);

  bool get isEmpty => max <= min;
}

main() {
  final interval = Interval<double>(0, 1);
  print(interval.isEmpty); // false
}

'double?' doesn't conform to the bound 'num' of the type parameter 'T'.

class Interval<T extends num?> {
  T min, max;

  Interval(this.min, this.max);

  bool get isEmpty {
    var localMin = min;
    var localMax = max;

    // No min or max means an open-ended interval.
    if (localMin == null || localMax == null) return false;
    return localMax <= localMin;
  }
}

void main() {
  var map = {'key': 'value'};
  print(map['key'].length);
}

The property 'length' can't be unconditionally accessed because the receiver can be 'null'.

void main() {
  var map = {'key': 'value'};
  print(map['key']!.length); // 5
}

void main() {
  print(List<int?>());
}

The default 'List' constructor isn't available when null safety is enabled.

void main() {
  final list = [1, 2, 3];
  final cursor = list.iterator;
  
  print(cursor.current); // Error

  while (cursor.moveNext()) {
    print(cursor.current);
  }
  
  print(cursor.current); // Error
}