诊断消息

此页面列出了 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注释的映射参数中的值不是以下整数类型之一时，分析器会产生此诊断信息。

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

以下代码会产生此诊断信息，因为映射项的值为Array<Uint8>，这不是有效的整数类型。

import 'dart:ffi';

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

在映射中使用其中一个有效类型作为值。

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;

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

当代码引用对象的成员（例如，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 互操作。

以下代码会产生此诊断信息，因为字段 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);
}

参数类型“{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

更改资产映射，使其包含一个path字段，该字段具有字符串值（有效的 POSIX 风格文件路径）

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映射，使其包含一个值为字符串（有效的 POSIX 风格文件路径）的path值。

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 的调用，但没有 setter，因为具有相同名称的字段被声明为final或const时，会产生此诊断信息。

以下代码产生此诊断信息，因为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包含一个异步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);
  }
}

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

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

以下代码产生此诊断是因为在v的初始化器中使用了await表达式，而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;
}

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

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

如果扩展类型旨在可等待，则在implements子句中添加Future（或Future的子类型）（如果不存在则添加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;
}

如果函数应该沿着该路径返回非空值，则添加缺少的 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 {}

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

FFI 回调不能接受类型化数据参数或返回值。

当Pointer.fromFunction的调用，NativeCallable的构造函数之一具有类型化数据参数或返回值时，分析器会生成此诊断信息。

类型化数据解包仅在叶 FFI 调用的参数上受支持。

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

以下代码会生成此诊断信息，因为g的参数类型是类型化数据。

import 'dart:ffi';
import 'dart:typed_data';

void f(Uint8List i) {}

void g() {
  Pointer.fromFunction<Void Function(Pointer<Uint8>)>(f);
}

使用Pointer类型代替。

import 'dart:ffi';

void f(Pointer<Uint8> i) {}

void g() {
  Pointer.fromFunction<Void Function(Pointer<Uint8>)>(f);
}

FFI 调用不能返回类型化数据。

当Pointer.asFunction、DynamicLibrary.lookupFunction或@Native的返回类型是类型化数据时，分析器会生成此诊断信息。

类型化数据解包仅在叶 FFI 调用的参数上受支持。

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

以下代码会生成此诊断信息，因为 dart 函数签名包含类型化数据，但isLeaf参数为false

import 'dart:ffi';
import 'dart:typed_data';

void f(Pointer<NativeFunction<Pointer<Uint8> Function()>> p) {
  p.asFunction<Uint8List Function()>();
}

使用Pointer类型代替。

import 'dart:ffi';

void f(Pointer<NativeFunction<Pointer<Uint8> Function()>> p) {
  p.asFunction<Pointer<Uint8> Function()>();
}

'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 {}

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

mixin class M {}
class C with M {}

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

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

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

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

来自延迟库的常量值不能用作 'const' 集合文字中的值。

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

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

给定一个定义常量 zero 的文件 a.dart

const zero = 0;

以下代码会生成此诊断信息，因为常量列表文字包含 a.zero，它使用 deferred 导入进行导入

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 可以为两个类型参数指定相同的类型。

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

'{0}' 不能同时用作类型变量和定义该类型变量的类的名称。

'{0}' 不能同时用作类型变量和定义该类型变量的枚举的名称。

'{0}' 不能同时用作类型变量和定义该类型变量的扩展的名称。

'{0}' 不能同时用作类型变量和定义该类型变量的扩展类型的名称。

'{0}' 不能同时用作类型变量和定义该类型变量的 mixin 的名称。

当类、mixin 或扩展声明使用与声明它的类、mixin 或扩展相同的名称声明类型参数时，分析器会生成此诊断。

以下代码会生成此诊断，因为类型参数 C 与它所属的类 C 的名称相同

class C<C> {}

重命名类型参数或类、mixin 或扩展

class C<T> {}

'{0}' 不能同时用作类型变量和此类中的成员的名称。

'{0}' 不能同时用作类型变量和此枚举中的成员的名称。

'{0}' 不能同时用作类型变量和此扩展类型中的成员的名称。

'{0}' 不能同时用作类型变量和此扩展中的成员的名称。

'{0}' 不能同时用作类型变量和此 mixin 中的成员的名称。

当类、mixin 或扩展声明使用与声明它的类、mixin 或扩展的成员之一相同的名称声明类型参数时，分析器会生成此诊断。

以下代码会生成此诊断，因为类型参数 T 与字段 T 的名称相同

class C<T> {
  int T = 0;
}

重命名类型参数或与之冲突的成员

class C<T> {
  int total = 0;
}

匹配的值类型 '{0}' 永远不可能等于此类型为 '{1}' 的常量。

当常量模式永远无法匹配它正在测试的值，因为常量的类型已知永远不会匹配值的类型时，分析器会生成此诊断。

以下代码会生成此诊断，因为常量模式 (true) 的类型为 bool，而正在匹配的值 (x) 的类型为 int，布尔值永远无法匹配整数

void f(int x) {
  if (x case true) {}
}

如果值的类型正确，请重写模式以使其兼容

void f(int x) {
  if (x case 3) {}
}

如果常量的类型正确，则重写该值以使其兼容。

void f(bool x) {
  if (x case true) {}
}

常量模式的表达式必须是有效的常量。

当常量模式的表达式不是有效的常量时，分析器会生成此诊断。

以下代码会生成此诊断，因为常量模式 i 不是常量。

void f(int e, int i) {
  switch (e) {
    case i:
      break;
  }
}

如果要匹配的值已知，则将表达式替换为常量。

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

如果要匹配的值未知，则重写代码以不使用模式。

void f(int e, int i) {
  if (e == i) {}
}