诊断消息

此页面列出了 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 关键字

abstract class C {
  int f = 0;
}

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

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

以下代码生成此诊断消息，因为类 C 同时使用 abstract 和 sealed 声明

abstract sealed class C {}

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

abstract class C {}

如果类应该既是抽象的又是 sealed 的，则删除 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} 中定义。

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

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

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 或 Set，因为它包含至少一个字面量 Map 条目或展开 'Map' 的展开运算符，以及至少一个既不是这两者之一的元素。

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

当至少一个元素是字面量 Map 条目或展开 'Map' 的展开运算符，并且至少一个元素既不是这两者之一时，分析器会生成此诊断消息，这使得分析器无法确定您是在编写 Map 字面量还是 Set 字面量。

以下代码生成此诊断消息：

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

列表 b 只能展开到 Set 中，而 Map a 和 c 只能展开到 Map 中，并且字面量不能两者都是。

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

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};

此字面量必须是 Map 或 Set，但元素没有足够的类型推断信息。

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

当正在展开的表达式都没有允许分析器确定您是在编写 Map 字面量还是 Set 字面量的类型时，会生成此诊断消息。

以下代码生成此诊断消息：

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

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

有三种常见的解决方法。第一种是向字面量添加类型参数。例如，如果字面量旨在成为 Map 字面量，则您可以编写如下代码：

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;
}

struct 类中类型为 'Pointer' 的字段不应有任何注解。

当在 Struct 的子类中声明且类型为 Pointer 的字段也具有与之关联的注解时，分析器会生成此诊断消息。

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

以下代码生成此诊断消息，因为字段 p 的类型为 Pointer，并且在 Struct 的子类中声明，并带有注解 @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' 初始化列表。

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

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

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

如果不需要 assert，则删除它

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

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

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 for-in 循环，但该函数或方法体未标记为 async 或 async* 时，分析器会产生此诊断。

以下代码产生此诊断，因为 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 值，则向闭包添加显式的 return

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。

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

以下代码产生此诊断，因为类 M 正在用作 mixin，但它未定义为 mixin class

class M {}
class C with M {}

如果该类可以是纯 mixin，则将 class 更改为 mixin

mixin M {}
class C with M {}

如果该类需要既是类又是 mixin，则添加 mixin

mixin class M {}
class C with M {}

来自延迟库的常量值不能用作 'const' 映射字面量中的键。

来自延迟库的常量值不能用作 'const' 构造函数中的值。

来自延迟库的常量值不能用作 'const' 列表字面量中的值。

来自延迟库的常量值不能用作 'const' 映射字面量中的值。

来自延迟库的常量值不能用作 'const' set 字面量中的值。

当显式（因为它以 const 关键字为前缀）或隐式（因为它出现在常量上下文中）为常量的集合字面量包含的值在延迟导入的库中声明时，分析器会产生此诊断。常量在编译时求值，而来自延迟库的值在编译时不可用。

有关更多信息，请查看 延迟加载库。

给定一个文件 a.dart，其中定义了常量 zero

const zero = 0;

以下代码产生此诊断，因为常量列表字面量包含使用 deferred 导入的 a.zero

import 'a.dart' deferred as a;

var l = const [a.zero];

如果集合字面量不需要是常量，则删除 const 关键字

import 'a.dart' deferred as a;

var l = [a.zero];

如果集合需要是常量，并且必须引用导入的常量，则从导入中删除关键字 deferred

import 'a.dart' as a;

var l = const [a.zero];

如果不需要引用常量，则将其替换为合适的值

var l = const [0];

类“{0}”不能实现 Finalizable。

当 Struct 或 Union 的子类实现 Finalizable 时，分析器会产生此诊断。

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

以下代码产生此诊断，因为类 S 实现了 Finalizable

import 'dart:ffi';

final class S extends Struct implements Finalizable {
  external Pointer notEmpty;
}

尝试从类中删除 implements 子句

import 'dart:ffi';

final class S extends Struct {
  external Pointer notEmpty;
}

具体类不能将 'Enum' 作为超接口。

当具体类间接将类 Enum 作为超接口时，分析器会产生此诊断。

以下代码产生此诊断，因为具体类 B 由于实现了 A 而将 Enum 作为超接口

abstract class A implements Enum {}

class B implements A {}

如果实现的类不是您想要实现的类，则更改它

abstract class A implements Enum {}

class B implements C {}

class C {}

如果可以将实现的类更改为不实现 Enum，则这样做

abstract class A {}

class B implements A {}

如果无法将实现的类更改为不实现 Enum，则从 implements 子句中删除它

abstract class A implements Enum {}

class B {}

“{0}”必须有方法体，因为“{1}”不是抽象的。

当在具体类中找到没有具体实现的成员时，分析器会产生此诊断。具体类不允许包含抽象成员。

以下代码产生此诊断，因为 m 是一个抽象方法，但 C 不是一个抽象类

class C {
  void m();
}

如果创建类的实例是有效的，请为成员提供实现

class C {
  void m() {}
}

如果创建类的实例无效，则将类标记为抽象类

abstract class C {
  void m();
}

“{0}”不能同时用作此类中的构造函数和静态字段的名称。

“{0}”不能同时用作此类中的构造函数和静态 getter 的名称。

“{0}”不能同时用作此类中的构造函数和静态方法的名称。

“{0}”不能同时用作此类中的构造函数和静态 setter 的名称。

当命名构造函数和静态方法或静态字段具有相同的名称时，分析器会产生此诊断。两者都使用类的名称访问，因此具有相同的名称会使引用变得模糊不清。

以下代码产生此诊断，因为静态字段 foo 和命名构造函数 foo 具有相同的名称

class C {
  C.foo();
  static int foo = 0;
}

以下代码产生此诊断，因为静态方法 foo 和命名构造函数 foo 具有相同的名称

class C {
  C.foo();
  static void foo() {}
}

重命名成员或构造函数。

{0}“{1}”不能同时实现“{2}”和“{3}”，因为类型参数不同。

当一个类尝试多次实现泛型接口，并且类型参数的值不相同时，分析器会产生此诊断。

以下代码产生此诊断，因为 C 被定义为同时实现 I<int>（因为它扩展了 A）和 I<String>（因为它实现了 B），但 int 和 String 不是相同的类型

class I<T> {}
class A implements I<int> {}
class B implements I<String> {}
class C extends A implements B {}

重新设计类型层次结构以避免这种情况。例如，您可以使一个或两个继承的类型成为泛型，以便 C 可以为两个类型参数指定相同的类型