Dartの静的解析について調べる

dart create hello_lint

void increment() {
  if (1 < 10) ;
}

Avoid empty statements

dart analyze

Analyzing hello_lint...                1.2s

   info • lib/hello_lint.dart:2:13 • Avoid empty statements. •
          empty_statements

1 issue found.

var controller = StreamController<String>();

info - Close instances of `dart.core.Sink`. - close_sinks

analyzer:
  language:
    strict-casts: true
    strict-inference: true
    strict-raw-types: true

  dynamic a = "1";
  String b = a;

error • lib/hello_lint.dart:12:14 • A value of type 'dynamic' can't be
          assigned to a variable of type 'String'. Try changing the type of
          the variable, or casting the right-hand type to 'String'. •
          invalid_assignment

final lines = {};

   info • lib/hello_lint.dart:11:17 • The type argument(s) of 'Map' can't be
          inferred. Use explicit type argument(s) for 'Map'. •
          inference_failure_on_collection_literal

final lines = <String, String>{};

List numbers = [1, 2, 3];

   info • lib/hello_lint.dart:11:3 • The generic type 'List<dynamic>' should
          have explicit type arguments but doesn't. Use explicit type
          arguments for 'List<dynamic>'. • strict_raw_type

include: package:lints/core.yaml
include: package:lints/recommended.yaml
include: package:flutter_lints/flutter.yaml

linter:
  rules:
    - always_declare_return_types
    - cancel_subscriptions
    - close_sinks
    - comment_references
    - one_member_abstracts
    - only_throw_errors
    - package_api_docs
    - prefer_final_in_for_each
    - prefer_single_quotes

linter:
  rules:
    avoid_shadowing_type_parameters: false
    await_only_futures: true

analyzer:
  exclude:
    - lib/client.dart
    - lib/server/*.g.dart
    - test/_data/**

// ignore_for_file: unused_local_variable

// ignore: invalid_assignment
int x = '';

int x = ''; // ignore: invalid_assignment

analyzer:
  errors:
    todo: ignore

analyzer:
  errors:
    invalid_assignment: warning
    missing_return: error
    dead_code: info

bool b = [0][0];

error • lib/hello_lint.dart:13:12 • A value of type 'int' can't be assigned to a variable of type 'bool'. Try
          changing the type of the variable, or casting the right-hand type to 'bool'. • invalid_assignment

class A {
  void method1() {}
}

class B extends A {
  void method2() {}
}

A makeA() {
  return B();
}

void main() {
  final b = makeA();
  b.method2();
}

  error • lib/hello_lint.dart:19:5 • The method 'method2' isn't defined for the type 'A'. Try correcting the name to
          the name of an existing method, or defining a method named 'method2'. • undefined_method

void main() {
  final b = makeA() as B;
  b.method2();
}

class C<T extends Iterable> {
  final T collection;
  C(this.collection);
}

void main() {
  var c = C(Iterable.empty()).collection;
  c.add(2);
}

  error • lib/hello_lint.dart:8:5 • The method 'add' isn't defined for the type 'Iterable'. Try correcting the name
          to the name of an existing method, or defining a method named 'add'. • undefined_method

void main() {
  var c = C<List>([]).collection;
  c.add(2);
}

abstract class NumberAdder {
  num add(num a, num b);
}

class MyAdder extends NumberAdder {
  @override
  num add(int a, int b) => a + b;
}

  error • lib/hello_lint.dart:7:7 • 'MyAdder.add' ('num Function(int, int)') isn't a valid override of 'NumberAdder.add'
          ('num Function(num, num)'). • invalid_override
           - The member being overridden at lib/hello_lint.dart:2:7.

class MyAdder extends NumberAdder {
  @override
  num add(num a, num b) => a + b;
}

class Superclass<T> {
  void method(T param) { ... }
}

class Subclass extends Superclass {
  @override
  void method(int param) { ... }
}

  error • lib/hello_lint.dart:7:8 • 'Subclass.method' ('void Function(int)') isn't a valid override of
          'Superclass.method' ('void Function(dynamic)'). • invalid_override
           - The member being overridden at lib/hello_lint.dart:2:8.

class Superclass<T> {
  void method(T param) { ... }
}

class Subclass extends Superclass<int> {
  @override
  void method(int param) { ... }
}

analyzer:
  language:
    strict-raw-types: true

void main() {
  var map = {'a': 1, 'b': 2, 'c': 3};
  map['d'] = 1.5;
}

  error • lib/hello_lint.dart:3:14 • A value of type 'double' can't be assigned to a variable of type 'int'.
          Try changing the type of the variable, or casting the right-hand type to 'int'. •
          invalid_assignment

void main() {
  var map = <String, num>{'a': 1, 'b': 2, 'c': 3};
  map['d'] = 1.5;
}

class A {
  String name;
  A(this.name);
}

class B extends A {
  int _age;

  B(String firstname, String familyname, int age)
      : super("$firstname $familyname"),
        _age = age;
}

  error • lib/hello_lint.dart:10:9 • The superconstructor call must be last in an initializer list: 'A'. •
          super_invocation_not_last

class A {
  String name;
  A(this.name);
}

class B extends A {
  final int _age;

  B(String firstname, String familyname, int age)
      : _age = age,
        super("$firstname $familyname");
}

void filterValues(bool Function(dynamic) filter) {}

void main() {
  filterValues((String x) => x.contains('Hello'));
}

  error • lib/hello_lint.dart:4:16 • The argument type 'bool Function(String)' can't be assigned to the parameter
          type 'bool Function(dynamic)'. • argument_type_not_assignable

void filterValues<T>(bool Function(T) filter) {}

void main() {
  filterValues((String x) => x.contains('Hello'));
}

void filterValues<T>(bool Function(dynamic) filter) {}

void main() {
  filterValues((x) => (x as String).contains('Hello'));
}

void filterValues<T>(dynamic something) {}

void main() {
  filterValues("string");
}

void main() {
  List<int> ints = [1, 2, 3];
  var maximumOrNull = ints.fold(null, (a, b) => a == null || a < b ? b : a);
}

  error • lib/hello_lint.dart:3:49 • The return type 'Object' isn't a 'Null', as required by the closure's
          context. • return_of_invalid_type_from_closure

void main() {
  List<int> ints = [1, 2, 3];
  var maximumOrNull = ints.fold<int?>(null, (a, b) => a == null || a < b ? b : a);
}

void assumeStrings(dynamic objects) {
  List<String> strings = objects; // Runtime downcast check
  String string = strings[0]; // Expect a String value
}

void main() {
  assumeStrings([1, 2, 3]);
}

Unhandled exception:
type 'List<int>' is not a subtype of type 'List<String>'
#0      assumeStrings
bin/hello_lint.dart:2
#1      main
bin/hello_lint.dart:7
#2      _delayEntrypointInvocation.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:297:19)
#3      _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:192:12)

Exited (255)

void assumeStrings(dynamic objects) {
  List<String> strings = objects; // Runtime downcast check
  String string = strings[0]; // Expect a String value
}

void main() {
  assumeStrings([1, 2, 3].cast<String>());
}

Unhandled exception:
type 'int' is not a subtype of type 'String' in type cast
#0      _CastListBase.[] (dart:_internal/cast.dart:99:46)
#1      assumeStrings
bin/hello_lint.dart:3
#2      main
bin/hello_lint.dart:7
#3      _delayEntrypointInvocation.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:297:19)
#4      _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:192:12)

Exited (255)

abstract class NumberAdder {
  num add(num a, num b);
}

class MyAdder extends NumberAdder {
  @override
  num add(covariant int a, covariant int b) => a + b;
}

abstract class NumberAdder {
  num add(covariant num a, covariant num b);
}

class MyAdder extends NumberAdder {
  @override
  num add(int a, int b) => a + b;
}

var l = const [/*constant context*/];
var p = const Point(/*constant context*/);
const v = /*constant context*/;

void f(int e) {
  switch (e) {
    case /*constant context*/:
      break;
  }
}

// Definitely assigned
void f(String name) {
  String s = 'Hello $name!';
  print(s);
}

// Definitely unassigned
void g() {
  String s;
  print(s);
}

// Might or might not be assigned
void g(String name, bool casual) {
  String s;
  if (casual) {
    s = 'Hi $name!';
  }
  print(s);
}

class A {}
mixin M {}

class B extends A with M {}

class A {}
mixin M {}
class A_M = A with M;

class B extends A_M {}

class A {
  int m(String s) => 0;
}

class B extends A {
  @override
  m(s) => 1;
}

class A {
  int m(num n) => 0;
}

class B {
  num m(int i) => 0;
}

class C implements A, B {
  @override
  m(n) => 1;
}

import 'package:a/a.dart';

dependencies:

import 'dart:io';

void someFunction(filename) {
  IOSink sink = File(filename).openWrite();
  sink.flush();
}

linter:
  rules:
    - close_sinks

info • lib/hello_lint.dart:4:10 • Close instances of `dart.core.Sink`. • close_sinks