诊断消息

此页面列出了 Dart 分析器生成的诊断消息，其中包含有关这些消息的含义以及如何修复代码的详细信息。 有关分析器的更多信息，请参阅 自定义静态分析。

分析器为不符合语言规范或可能以意外方式工作的代码生成以下诊断信息。

扩展 'AbiSpecificInteger' 的类必须只有一个 const 构造函数，没有其他成员，也没有类型参数。

当扩展 AbiSpecificInteger 的类不满足以下所有要求时，分析器会生成此诊断信息

• 必须只有一个构造函数
• 构造函数必须标记为 const
• 除了一个构造函数外，不能有任何其他成员
• 不能有任何类型参数

以下代码生成此诊断信息，因为类 C 未定义 const 构造函数

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C extends AbiSpecificInteger {
}

以下代码生成此诊断信息，因为构造函数不是 const 构造函数

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C extends AbiSpecificInteger {
  C();
}

以下代码生成此诊断信息，因为类 C 定义了多个构造函数

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C extends AbiSpecificInteger {
  const C.zero();
  const C.one();
}

以下代码生成此诊断信息，因为类 C 定义了一个字段

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C extends AbiSpecificInteger {
  final int i;

  const C(this.i);
}

以下代码生成此诊断信息，因为类 C 具有类型参数

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C<T> extends AbiSpecificInteger { // type parameters
  const C();
}

更改类，使其满足没有类型参数和单个成员（即 const 构造函数）的要求

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C extends AbiSpecificInteger {
  const C();
}

扩展 'AbiSpecificInteger' 的类必须只有一个 'AbiSpecificIntegerMapping' 注解，用于指定从 ABI 到具有固定大小的 'NativeType' 整数的映射。

当扩展 AbiSpecificInteger 的类具有多个 AbiSpecificIntegerMapping 注解时，分析器会生成此诊断信息。

以下代码生成此诊断信息，因为类 C 上有两个 AbiSpecificIntegerMapping 注解

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
@AbiSpecificIntegerMapping({Abi.linuxX64 : Uint16()})
final class C extends AbiSpecificInteger {
  const C();
}

删除除一个之外的所有注解，并根据需要合并参数

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8(), Abi.linuxX64 : Uint16()})
final class C extends AbiSpecificInteger {
  const C();
}

扩展 'AbiSpecificInteger' 的类必须只有一个 'AbiSpecificIntegerMapping' 注解，用于指定从 ABI 到具有固定大小的 'NativeType' 整数的映射。

当扩展 AbiSpecificInteger 的类没有 AbiSpecificIntegerMapping 注解时，分析器会生成此诊断信息。

以下代码生成此诊断信息，因为类 C 上没有 AbiSpecificIntegerMapping 注解

import 'dart:ffi';

final class C extends AbiSpecificInteger {
  const C();
}

向类添加 AbiSpecificIntegerMapping 注解

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C extends AbiSpecificInteger {
  const C();
}

到 '{0}' 的映射无效；仅支持映射到 'Int8'、'Int16'、'Int32'、'Int64'、'Uint8'、'Uint16'、'UInt32' 和 'Uint64'。

当 AbiSpecificIntegerMapping 注解的 map 参数中的值不是以下整数类型之一时，分析器会生成此诊断信息

• Int8
• Int16
• Int32
• Int64
• Uint8
• Uint16
• UInt32
• Uint64

以下代码生成此诊断信息，因为 map 条目的值是 Array<Uint8>，这不是有效的整数类型

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Array<Uint8>(4)})
final class C extends AbiSpecificInteger {
  const C();
}

在 map 中使用一个有效类型作为值

import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C extends AbiSpecificInteger {
  const C();
}

抽象字段不能有初始化程序。

当具有 abstract 修饰符的字段也有初始化程序时，分析器会生成此诊断信息。

以下代码生成此诊断信息，因为 f 标记为 abstract 并且具有初始化程序

abstract class C {
  abstract int f = 0;
}

以下代码生成此诊断信息，因为 f 标记为 abstract，并且构造函数中有一个初始化程序

abstract class C {
  abstract int f;

  C() : f = 0;
}

如果该字段必须是抽象的，则删除初始化程序

abstract class C {
  abstract int f;
}

如果该字段不需要是抽象的，则删除关键字

abstract class C {
  int f = 0;
}

'sealed' 类不能标记为 'abstract'，因为它已经是隐式抽象的。

当使用修饰符 abstract 和修饰符 sealed 声明类时，分析器会生成此诊断信息。 密封类是隐式抽象的，因此不允许显式使用这两个修饰符。

以下代码生成此诊断信息，因为类 C 是使用 abstract 和 sealed 声明的

abstract sealed class C {}

如果类应该抽象但不是密封的，则删除 sealed 修饰符

abstract class C {}

如果类既应该是抽象的又是密封的，则删除 abstract 修饰符

sealed class C {}

超类型中的 {0} '{1}' 始终是抽象的。

当使用 super 引用继承的成员时，如果超类链中没有该成员的具体实现，则分析器会生成此诊断信息。 不能调用抽象成员。

以下代码生成此诊断信息，因为 B 没有继承 a 的具体实现

abstract class A {
  int get a;
}
class B extends A {
  int get a => super.a;
}

删除对抽象成员的调用，可能会将其替换为对具体成员的调用。

名称 '{0}' 在库 '{1}' 和 '{2}' 中定义。

当两个或多个导出指令导致从多个库导出同一名称时，分析器会生成此诊断信息。

给定一个包含以下内容的 a.dart 文件

class C {}

和一个包含以下内容的 b.dart 文件

class C {}

以下代码生成此诊断信息，因为名称 C 同时从 a.dart 和 b.dart 导出

export 'a.dart';
export 'b.dart';

如果一个库中的任何名称都不需要导出，则删除不必要的导出指令

export 'a.dart';

如果需要所有导出指令，则在除一个指令之外的所有指令中隐藏该名称

export 'a.dart';
export 'b.dart' hide C;

名为 '{0}' 的成员在 '{1}' 和 '{2}' 中定义，并且两者都不更具体。

名为 '{0}' 的成员在 {1} 中定义，并且没有一个更具体。

当代码引用对象的成员（例如，o.m() 或 o.m 或 o[i]），而 o 的静态类型未声明该成员（例如 m 或 []）时，分析器会尝试在扩展中查找该成员。 例如，如果该成员是 m，则分析器会查找声明名为 m 的成员且具有可以将 o 的静态类型分配到的扩展类型的扩展。 当范围内有多个此类扩展时，会选择其扩展类型最具体的扩展。

当没有一个扩展的扩展类型比所有其他扩展的扩展类型更具体时，分析器会生成此诊断信息，这使得对成员的引用不明确。

以下代码生成此诊断信息，因为无法在 E1 中的成员和 E2 中的成员之间进行选择

extension E1 on String {
  int get charCount => 1;
}

extension E2 on String {
  int get charCount => 2;
}

void f(String s) {
  print(s.charCount);
}

如果不需要两个扩展，则可以删除或隐藏其中一个。

如果两者都需要，请使用扩展覆盖显式选择要使用的一个。

extension E1 on String {
  int get charCount => length;
}

extension E2 on String {
  int get charCount => length;
}

void f(String s) {
  print(E2(s).charCount);
}

名称“{0}”在库 {1} 中定义。

当引用的名称在两个或多个导入的库中声明时，分析器会产生此诊断。

给定一个定义了类（本例中为 C）的库 (a.dart)

class A {}
class C {}

以及一个定义了同名但不同的类的库 (b.dart)

class B {}
class C {}

以下代码会产生此诊断

import 'a.dart';
import 'b.dart';

void f(C c1, C c2) {}

如果不需要任何库，请删除它们的导入指令

import 'a.dart';

void f(C c1, C c2) {}

如果该名称仍然由多个库定义，则为除一个库之外的所有库的导入指令添加 hide 子句

import 'a.dart' hide C;
import 'b.dart';

void f(C c1, C c2) {}

如果必须能够引用多个这些类型，则为每个导入指令添加前缀，并使用相应的前缀限定引用

import 'a.dart' as a;
import 'b.dart' as b;

void f(a.C c1, b.C c2) {}

字面量不能是映射或集合，因为它包含至少一个字面量映射条目或一个扩展 Map 的展开运算符，并且至少包含一个非上述项的元素。

由于映射和集合字面量使用相同的分隔符（{ 和 }），因此分析器会查看类型参数和元素来确定您指的是哪种字面量。 当没有类型参数时，分析器会使用元素的类型。如果所有元素都是字面量映射条目，并且所有展开运算符都在展开 Map，则它是 Map。 如果没有元素是字面量映射条目，并且所有展开运算符都在展开 Iterable，则它是 Set。 如果两者都不是真的，则它是模棱两可的。

当至少一个元素是字面量映射条目或一个展开 Map 的展开运算符，并且至少一个元素不是上述两者之一时，分析器会产生此诊断，这使得分析器无法确定您是在编写映射字面量还是集合字面量。

以下代码会产生此诊断

union(Map<String, String> a, List<String> b, Map<String, String> c) =>
    {...a, ...b, ...c};

列表 b 只能展开到集合中，而映射 a 和 c 只能展开到映射中，而字面量不能同时是两者。

有两种常见的解决方法。第一种是删除一种或另一种的所有展开元素，以便元素保持一致。在这种情况下，这可能意味着删除列表并决定如何处理现在未使用的参数

union(Map<String, String> a, List<String> b, Map<String, String> c) =>
    {...a, ...c};

第二种解决方法是将一种元素的类型更改为与另一种元素一致的类型。例如，您可以将列表的元素添加为映射到自身的键

union(Map<String, String> a, List<String> b, Map<String, String> c) =>
    {...a, for (String s in b) s: s, ...c};

此字面量必须是映射或集合，但元素没有足够的信息来使类型推断工作。

由于映射和集合字面量使用相同的分隔符（{ 和 }），因此分析器会查看类型参数和元素来确定您指的是哪种字面量。 当没有类型参数并且所有元素都是展开元素（两种字面量都允许）时，分析器会使用正在展开的表达式的类型。 如果所有表达式的类型都是 Iterable，则它是集合字面量；如果它们的类型都是 Map，则它是映射字面量。

当没有展开的表达式的类型允许分析器确定您是在编写映射字面量还是集合字面量时，会产生此诊断。

以下代码会产生此诊断

union(a, b) => {...a, ...b};

发生此问题的原因是没有类型参数，并且没有关于 a 或 b 类型的信息。

有三种常见的解决方法。第一种是将类型参数添加到字面量。 例如，如果字面量旨在成为映射字面量，您可能会编写类似这样的内容

union(a, b) => <String, String>{...a, ...b};

第二种解决方法是添加类型信息，使表达式具有 Iterable 类型或 Map 类型。您可以添加显式类型转换，或者，在本例中，将类型添加到两个参数的声明中

union(List<int> a, List<int> b) => {...a, ...b};

第三种解决方法是添加上下文信息。 在这种情况下，这意味着向函数添加返回类型

Set<String> union(a, b) => {...a, ...b};

在其他情况下，您可能需要在其他地方添加类型。 例如，假设原始代码如下所示

union(a, b) {
  var x = {...a, ...b};
  return x;
}

您可能会在 x 上添加类型注释，如下所示

union(a, b) {
  Map<String, String> x = {...a, ...b};
  return x;
}

类型为“Pointer”的结构类中的字段不应具有任何注解。

当在 Struct 的子类中声明并且具有 Pointer 类型的字段还具有与其关联的注解时，分析器会产生此诊断。

有关 FFI 的更多信息，请参阅使用 dart:ffi 进行 C 互操作。

以下代码产生此诊断，因为类型为 Pointer 且在 Struct 的子类中声明的字段 p 具有注解 @Double()

import 'dart:ffi';

final class C extends Struct {
  @Double()
  external Pointer<Int8> p;
}

从字段中删除注解

import 'dart:ffi';

final class C extends Struct {
  external Pointer<Int8> p;
}

参数“{0}”必须是常量。

当调用 Pointer.asFunction 或 DynamicLibrary.lookupFunction 的 isLeaf 参数的值不是常量表达式时，分析器会产生此诊断。

当调用 Pointer.fromFunction 或 NativeCallable.isolateLocal 的 exceptionalReturn 参数的值不是常量表达式时，分析器也会产生此诊断。

有关 FFI 的更多信息，请参阅使用 dart:ffi 进行 C 互操作。

以下代码产生此诊断，因为 isLeaf 参数的值是一个参数，因此不是常量

import 'dart:ffi';

int Function(int) fromPointer(
    Pointer<NativeFunction<Int8 Function(Int8)>> p, bool isLeaf) {
  return p.asFunction(isLeaf: isLeaf);
}

如果有合适的常量可以使用，则用常量替换参数

import 'dart:ffi';

const isLeaf = false;

int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
  return p.asFunction(isLeaf: isLeaf);
}

如果没有合适的常量，则用布尔字面量替换参数

import 'dart:ffi';

int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
  return p.asFunction(isLeaf: true);
}

“Native.addressOf”的参数必须使用 @Native 注解

当传递给 Native.addressOf 的参数没有使用 Native 注解时，分析器会产生此诊断。

以下代码产生此诊断，因为 addressOf 的参数是一个字符串，而不是一个字段，并且字符串不能被注解

import 'dart:ffi';

@Native<Void Function()>()
external void f();

void g() {
  print(Native.addressOf('f'));
}

以下代码产生此诊断，因为函数 f 被传递给 addressOf，但没有被注解为 Native

import 'dart:ffi';

external void f();

void g() {
  print(Native.addressOf<NativeFunction<Void Function()>>(f));
}

如果参数不是字段或函数，则用使用 Native 注解的字段或函数替换参数

import 'dart:ffi';

@Native<Void Function()>()
external void f();

void g() {
  print(Native.addressOf<NativeFunction<Void Function()>>(f));
}

如果参数是字段或函数，则使用 Native 注解字段或函数

import 'dart:ffi';

@Native<Void Function()>()
external void f();

void g() {
  print(Native.addressOf<NativeFunction<Void Function()>>(f));
}

参数类型“{0}”不能分配给参数类型“{1}”。 {2}

当参数的静态类型无法分配给相应参数的静态类型时，分析器会产生此诊断。

以下代码产生此诊断，因为 num 不能分配给 String

String f(String x) => x;
String g(num y) => f(y);

如果可能，重写代码，以便静态类型可分配。 在上面的示例中，您可能能够更改参数 y 的类型

String f(String x) => x;
String g(String y) => f(y);

如果无法进行此修复，则添加代码来处理参数值不是所需类型的情况。 一种方法是将其他类型强制转换为所需的类型

String f(String x) => x;
String g(num y) => f(y.toString());

另一种方法是添加显式类型测试和回退代码

String f(String x) => x;
String g(Object y) => f(y is String ? y : '');

如果您认为参数的运行时类型将始终与参数的静态类型相同，并且您愿意承担如果出错会在运行时引发异常的风险，则添加显式类型转换

String f(String x) => x;
String g(num y) => f(y as String);

参数类型“{0}”不能分配给参数类型“{1} Function(Object)”或“{1} Function(Object, StackTrace)”。

当调用 Future.catchError 的参数是一个函数，并且该函数的参数与调用该函数时将传递给该函数的参数不兼容时，分析器会产生此诊断。 catchError 的第一个参数的静态类型只是 Function，即使传入的函数应该具有一个 Object 类型的参数，或者两个 Object 和 StackTrace 类型的参数。

以下代码产生此诊断，因为传递给 catchError 的闭包不接受任何参数，但该函数需要至少接受一个参数

void f(Future<int> f) {
  f.catchError(() => 0);
}

以下代码产生此诊断，因为传递给 catchError 的闭包接受三个参数，但它不能有超过两个必需参数

void f(Future<int> f) {
  f.catchError((one, two, three) => 0);
}

以下代码产生此诊断，因为即使传递给 catchError 的闭包接受一个参数，该闭包的类型也不与 Object 兼容

void f(Future<int> f) {
  f.catchError((String error) => 0);
}

更改传递给 catchError 的函数，使其具有一个或两个必需参数，并且参数具有所需的类型

void f(Future<int> f) {
  f.catchError((Object error) => 0);
}

重定向构造函数不能具有“assert”初始化器。

当重定向构造函数（重定向到同一类中的另一个构造函数的构造函数）在初始化列表中具有断言时，分析器会产生此诊断。

以下代码产生此诊断，因为未命名的构造函数是一个重定向构造函数，并且在初始化列表中也有一个断言

class C {
  C(int x) : assert(x > 0), this.name();
  C.name() {}
}

如果不需要断言，则删除它

class C {
  C(int x) : this.name();
  C.name() {}
}

如果需要断言，则将构造函数转换为工厂构造函数

class C {
  factory C(int x) {
    assert(x > 0);
    return C.name();
  }
  C.name() {}
}

资源目录“{0}”不存在。

当资源列表包含引用不存在的目录的值时，分析器会产生此诊断。

假设目录 assets 不存在，则以下代码会产生此诊断，因为它被列为包含资源的目录

name: example
flutter:
  assets:
    - assets/

如果路径正确，则在该路径下创建一个目录。

如果路径不正确，则更改路径以匹配包含资源的目录的路径。

资源文件“{0}”不存在。

当资源列表包含引用不存在的文件的值时，分析器会产生此诊断。

假设文件 doesNotExist.gif 不存在，则以下代码会产生此诊断，因为它被列为资源

name: example
flutter:
  assets:
    - doesNotExist.gif

如果路径正确，则在该路径下创建一个文件。

如果路径不正确，则更改路径以匹配包含资源的文件的路径。

“assets”字段的值应为相对文件路径的列表。

当 assets 键的值不是列表时，分析器会产生此诊断。

以下代码产生此诊断，因为 assets 键的值是一个字符串，而应为列表

name: example
flutter:
  assets: assets/

更改资源列表的值，使其成为列表

name: example
flutter:
  assets:
    - assets/

资源映射条目必须包含“path”字段。

当资源映射缺少 path 值时，分析器会产生此诊断。

以下代码产生此诊断，因为资源映射缺少 path 值

name: example
flutter:
  assets:
    - flavors:
      - premium

更改资源映射，使其包含具有字符串值（有效的 POSIX 样式文件路径）的 path 字段

name: example
flutter:
  assets:
    - path: assets/image.gif
      flavors:
      - premium

资源必须是文件路径（字符串）。

当 assets 列表包含一个不是字符串的值时，分析器会产生此诊断。

以下代码产生此诊断，因为 assets 列表包含一个映射

name: example
flutter:
  assets:
    - image.gif: true

更改 assets 列表，使其仅包含有效的 POSIX 样式文件路径

name: example
flutter:
  assets:
    - assets/image.gif

资源值必须是文件路径（字符串）或映射。

当资源值不是字符串或映射时，分析器会产生此诊断。

以下代码产生此诊断，因为资源值是一个列表

name: example
flutter:
  assets:
    - [one, two, three]

如果您需要指定不仅仅是资源的路径，则用具有 path 键（有效的 POSIX 样式文件路径）的映射替换该值

name: example
flutter:
  assets:
    - path: assets/image.gif
      flavors:
      - premium

如果您只需要指定路径，则用资源的路径（有效的 POSIX 样式文件路径）替换该值

name: example
flutter:
  assets:
    - assets/image.gif

资源路径必须是文件路径（字符串）。

当资源映射包含一个不是字符串的 path 值时，分析器会产生此诊断。

以下代码会产生此诊断，因为资源映射包含一个列表类型的 path 值。

name: example
flutter:
  assets:
    - path: [one, two, three]
      flavors:
      - premium

更改 asset 映射，使其包含一个字符串类型的 path 值（有效的 POSIX 风格文件路径）。

name: example
flutter:
  assets:
    - path: image.gif
      flavors:
      - premium

“{0}”被标记为“doNotStore”，不应赋值给字段或顶级变量。

当显式或隐式标记为 doNotStore 注解的函数（包括方法和 getter）的值存储在字段或顶级变量中时，分析器会产生此诊断。

以下代码会产生此诊断，因为函数 f 的值存储在顶级变量 x 中。

import 'package:meta/meta.dart';

@doNotStore
int f() => 1;

var x = f();

将对字段或变量的引用替换为生成值的函数的调用。

常量变量不能被赋值。

当分析器发现对具有 const 修饰符的顶级变量、静态字段或局部变量进行赋值时，会产生此诊断。编译时常量的值在运行时不能更改。

以下代码会产生此诊断，因为 c 被赋值，即使它具有 const 修饰符。

const c = 0;

void f() {
  c = 1;
  print(c);
}

如果变量必须可赋值，则删除 const 修饰符。

var c = 0;

void f() {
  c = 1;
  print(c);
}

如果常量不应更改，则删除赋值或使用局部变量代替对常量的引用。

const c = 0;

void f() {
  var v = 1;
  print(v);
}

“{0}”不能用作 setter，因为它已被声明为 final。

当分析器发现对 setter 的调用，但由于同名字段声明为 final 或 const 而没有 setter 时，会产生此诊断。

以下代码会产生此诊断，因为 v 是 final。

class C {
  final v = 0;
}

f(C c) {
  c.v = 1;
}

如果需要设置字段的值，则从字段中删除修饰符 final。

class C {
  int v = 0;
}

f(C c) {
  c.v = 1;
}

final 变量“{0}”只能设置一次。

当一个声明为 final 的局部变量在初始化后被赋值时，分析器会产生此诊断。

以下代码会产生此诊断，因为 x 是 final，因此在初始化后不能为其赋值。

void f() {
  final x = 0;
  x = 3;
  print(x);
}

删除关键字 final，如果没有类型注解，则将其替换为 var。

void f() {
  var x = 0;
  x = 3;
  print(x);
}

类“{1}”中不存在名为“{0}”的 setter。

当找到对 setter 的引用时，分析器会产生此诊断；该类型没有定义 setter；但定义了同名的 getter。

以下代码会产生此诊断，因为 C 中没有名为 x 的 setter，但有一个名为 x 的 getter。

class C {
  int get x => 0;
  set y(int p) {}
}

void f(C c) {
  c.x = 1;
}

如果要调用现有的 setter，请更正名称。

class C {
  int get x => 0;
  set y(int p) {}
}

void f(C c) {
  c.y = 1;
}

如果要调用 setter 但它还不存在，则声明它。

class C {
  int get x => 0;
  set x(int p) {}
  set y(int p) {}
}

void f(C c) {
  c.x = 1;
}

函数不能被赋值。

当函数名称出现在赋值表达式的左侧时，分析器会产生此诊断。

以下代码会产生此诊断，因为对函数 f 的赋值无效。

void f() {}

void g() {
  f = () {};
}

如果右侧应赋值给其他内容（例如局部变量），则更改左侧。

void f() {}

void g() {
  var x = () {};
  print(x);
}

如果目的是更改函数的实现，则定义一个函数值变量而不是函数。

void Function() f = () {};

void g() {
  f = () {};
}

方法不能被赋值。

当赋值的目标是一个方法时，分析器会产生此诊断。

以下代码会产生此诊断，因为不能为 f 赋值，因为它是一个方法。

class C {
  void f() {}

  void g() {
    f = null;
  }
}

重写代码，使其没有对方法的赋值。

类型不能被赋值。

当类型名称出现在赋值表达式的左侧时，分析器会产生此诊断。

以下代码会产生此诊断，因为对类 C 的赋值无效。

class C {}

void f() {
  C = null;
}

如果右侧应赋值给其他内容（例如局部变量），则更改左侧。

void f() {}

void g() {
  var c = null;
  print(c);
}

async for-in 循环只能在 async 函数中使用。

当在主体未标记为 async 或 async* 的函数或方法中找到 async for-in 循环时，分析器会产生此诊断。

以下代码会产生此诊断，因为 f 的主体未标记为 async 或 async*，但 f 包含一个 async for-in 循环。

void f(list) {
  await for (var e in list) {
    print(e);
  }
}

如果函数应返回 Future，则用 async 标记主体。

Future<void> f(list) async {
  await for (var e in list) {
    print(e);
  }
}

如果函数应返回一个值 Stream，则用 async* 标记主体。

Stream<void> f(list) async* {
  await for (var e in list) {
    print(e);
  }
}

如果函数应该是同步的，则删除循环之前的 await。

void f(list) {
  for (var e in list) {
    print(e);
  }
}

“await”表达式不能用于“late”局部变量的初始化器。

当具有 late 修饰符的局部变量在初始化器中使用 await 表达式时，分析器会产生此诊断。

以下代码会产生此诊断，因为 await 表达式用于 v 的初始化器，v 是一个标记为 late 的局部变量。

Future<int> f() async {
  late var v = await 42;
  return v;
}

如果可以将初始化器重写为不使用 await，则重写它。

Future<int> f() async {
  late var v = 42;
  return v;
}

如果无法重写初始化器，则删除 late 修饰符。

Future<int> f() async {
  var v = await 42;
  return v;
}

“await”表达式不能用于不是“Future”子类型的扩展类型的表达式。

当 await 表达式中表达式的类型是扩展类型，并且该扩展类型不是 Future 的子类时，分析器会产生此诊断。

以下代码会产生此诊断，因为扩展类型 E 不是 Future 的子类。

extension type E(int i) {}

void f(E e) async {
  await e;
}

如果扩展类型定义正确，则删除 await。

extension type E(int i) {}

void f(E e) {
  e;
}

如果扩展类型旨在可等待，则将 Future（或 Future 的子类型）添加到 implements 子句（如果还没有，则添加一个 implements 子句），并使表示类型匹配。

extension type E(Future<int> i) implements Future<int> {}

void f(E e) async {
  await e;
}

主体可能会正常完成，导致返回“null”，但返回类型“{0}”是可能不可为空的类型。

当方法或函数的返回类型是可能不可为空的，但如果控制到达函数的末尾，则会隐式返回 null 时，分析器会产生此诊断。

以下代码会产生此诊断，因为方法 m 在方法的末尾插入了隐式返回 null，但是该方法声明为不返回 null。

class C {
  int m(int t) {
    print(t);
  }
}

以下代码会产生此诊断，因为方法 m 在方法的末尾插入了隐式返回 null，但由于类 C 可以使用不可为空的类型参数实例化，因此该方法实际上被声明为不返回 null。

class C<T> {
  T m(T t) {
    print(t);
  }
}

如果有可以返回的合理值，则在方法的末尾添加 return 语句。

class C<T> {
  T m(T t) {
    print(t);
    return t;
  }
}

如果方法不会到达隐式返回，则在方法的末尾添加 throw。

class C<T> {
  T m(T t) {
    print(t);
    throw '';
  }
}

如果该方法有意在末尾返回 null，则在方法的末尾添加显式返回 null，并更改返回类型，使其可以返回 null。

class C<T> {
  T? m(T t) {
    print(t);
    return null;
  }
}

此“onError”处理程序必须返回可赋值给“{0}”的值，但结束时没有返回值。

当传递给 Future.catchError 方法的 onError 参数的闭包需要返回非 null 值（因为 Future 的类型参数），但可以隐式返回 null 时，分析器会产生此诊断。

以下代码会产生此诊断，因为传递给 catchError 方法的闭包需要返回 int，但没有以显式的 return 结尾，导致它隐式返回 null。

void g(Future<int> f) {
  f.catchError((e, st) {});
}

如果闭包有时应返回非 null 值，则向闭包添加显式返回。

void g(Future<int> f) {
  f.catchError((e, st) {
    return -1;
  });
}

如果闭包应始终返回 null，则将 Future 的类型参数更改为 void 或 Null。

void g(Future<void> f) {
  f.catchError((e, st) {});
}

此函数的返回类型为可空类型“{0}”，但结束时没有返回值。

当方法或函数可以通过超出末尾而隐式返回 null 时，分析器会产生此诊断。虽然这是有效的 Dart 代码，但最好显式返回 null。

以下代码会产生此诊断，因为函数 f 隐式返回 null。

String? f() {}

如果返回 null 是有意的，则将其显式化。

String? f() {
  return null;
}

如果函数应沿该路径返回非 null 值，则添加缺少的 return 语句。

String? f() {
  return '';
}

break 标签解析为“case”或“default”语句。

当 switch 语句内 case 子句中的 break 具有与另一个 case 子句关联的标签时，分析器会产生此诊断。

以下代码会产生此诊断，因为标签 l 与 0 的 case 子句相关联。

void f(int i) {
  switch (i) {
    l: case 0:
      break;
    case 1:
      break l;
  }
}

如果目的是将控制权转移到 switch 之后的语句，则从 break 语句中删除标签。

void f(int i) {
  switch (i) {
    case 0:
      break;
    case 1:
      break;
  }
}

如果目的是将控制权转移到不同的 case 块，则使用 continue 而不是 break。

void f(int i) {
  switch (i) {
    l: case 0:
      break;
    case 1:
      continue l;
  }
}

内置标识符“{0}”不能用作类型。

当在期望类型名称的地方使用内置标识符时，分析器会产生此诊断。

以下代码会产生此诊断，因为 import 不能用作类型，因为它是一个内置标识符。

import<int> x;

将内置标识符替换为有效类型的名称。

List<int> x;

内置标识符“{0}”不能用作前缀名称。

内置标识符“{0}”不能用作类型名称。

内置标识符“{0}”不能用作类型参数名称。

内置标识符“{0}”不能用作 typedef 名称。

内置标识符“{0}”不能用作扩展名。

内置标识符“{0}”不能用作扩展类型名称。

当类、扩展、mixin、typedef、类型参数或导入前缀的声明中使用的名称是内置标识符时，分析器会产生此诊断。内置标识符不能用于命名这些类型的声明。

以下代码会产生此诊断，因为 mixin 是一个内置标识符。

extension mixin on int {}

为声明选择一个不同的名称。

“case”的最后一条语句应该是“break”、“continue”、“rethrow”、“return”或“throw”。

当 case 块中的最后一条语句不是所需的终止符之一时，分析器会产生此诊断：break、continue、rethrow、return 或 throw。

以下代码会产生此诊断，因为 case 代码块以赋值语句结尾

void f(int x) {
  switch (x) {
    case 0:
      x += 2;
    default:
      x += 1;
  }
}

添加一个必需的终止符

void f(int x) {
  switch (x) {
    case 0:
      x += 2;
      break;
    default:
      x += 1;
  }
}

switch case 表达式类型 “{0}” 无法重写 “==” 运算符。

当关键字 case 后面的表达式类型具有 == 运算符的实现，且该实现不是 Object 中的实现时，分析器会产生此诊断。

以下代码会产生此诊断，因为关键字 case 后面的表达式 (C(0)) 的类型为 C，并且类 C 重写了 == 运算符

class C {
  final int value;

  const C(this.value);

  bool operator ==(Object other) {
    return false;
  }
}

void f(C c) {
  switch (c) {
    case C(0):
      break;
  }
}

如果没理由不这样做，请重写代码以使用 if-else 结构

class C {
  final int value;

  const C(this.value);

  bool operator ==(Object other) {
    return false;
  }
}

void f(C c) {
  if (c == C(0)) {
    // ...
  }
}

如果无法重写 switch 语句，并且 == 的实现不是必需的，请将其删除

class C {
  final int value;

  const C(this.value);
}

void f(C c) {
  switch (c) {
    case C(0):
      break;
  }
}

如果无法重写 switch 语句，并且无法删除 == 的定义，请找到可用于控制 switch 的其他值

class C {
  final int value;

  const C(this.value);

  bool operator ==(Object other) {
    return false;
  }
}

void f(C c) {
  switch (c.value) {
    case 0:
      break;
  }
}

switch case 表达式类型 “{0}” 必须是 switch 表达式类型 “{1}” 的子类型。

当 switch 语句中 case 后面的表达式的静态类型不是 switch 后面的表达式的静态类型的子类型时，分析器会产生此诊断。

以下代码会产生此诊断，因为 1 是 int 类型，它不是 String (s 的类型) 的子类型

void f(String s) {
  switch (s) {
    case 1:
      break;
  }
}

如果 case 表达式的值不正确，请更改 case 表达式，使其具有所需的类型

void f(String s) {
  switch (s) {
    case '1':
      break;
  }
}

如果 case 表达式的值正确，请更改 switch 表达式使其具有所需的类型

void f(int s) {
  switch (s) {
    case 1:
      break;
  }
}

此强制转换将始终引发异常，因为可为空的局部变量 “{0}” 未赋值。

当具有可空类型的局部变量尚未赋值并被强制转换为不可空类型时，分析器会产生此诊断。由于该变量尚未赋值，因此其默认值为 null，导致强制转换引发异常。

以下代码会产生此诊断，因为当已知变量 x 的值为 null 时，它被强制转换为不可空类型 (int)

void f() {
  num? x;
  x as int;
  print(x);
}

如果预计该变量在强制转换之前有值，请添加初始化器或赋值语句

void f() {
  num? x = 3;
  x as int;
  print(x);
}

如果预计该变量不会被赋值，请删除强制转换

void f() {
  num? x;
  print(x);
}

此强制转换始终引发异常，因为表达式始终计算为 “null”。

当类型为 Null 的表达式被强制转换为不可空类型时，分析器会产生此诊断。

以下代码会产生此诊断，因为已知 n 始终为 null，但它被强制转换为不可空类型

void f(Null n) {
  n as int;
}

删除不必要的强制转换

void f(Null n) {
  n;
}

名称 “{0}” 不是类型，因此不能在 “as” 表达式中使用。

当强制转换表达式中 as 后面的名称被定义为类型之外的其他内容时，分析器会产生此诊断。

以下代码会产生此诊断，因为 x 是一个变量，而不是类型

num x = 0;
int y = x as x;

将名称替换为类型的名称

num x = 0;
int y = x as int;

类 “{0}” 不能用作 mixin，因为它既不是 mixin 类也不是 mixin。

当 with 子句中使用既不是 mixin class 也不是 mixin 的类时，分析器会产生此诊断。

以下代码会产生此诊断，因为类 M 被用作 mixin，但它没有被定义为 mixin class

class M {}
class C with M {}

如果类可以是一个纯 mixin，请将 class 更改为 mixin

mixin M {}
class C with M {}