目录

诊断信息

目录 keyboard_arrow_down keyboard_arrow_up
more_horiz

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

诊断信息

#

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

abi_specific_integer_invalid

#

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

说明

#

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

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

示例

#

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

dart
import 'dart:ffi';

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

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

dart
import 'dart:ffi';

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

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

dart
import 'dart:ffi';

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

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

dart
import 'dart:ffi';

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

  const C(this.i);
}

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

dart
import 'dart:ffi';

@AbiSpecificIntegerMapping({Abi.macosX64 : Int8()})
final class C<T> extends AbiSpecificInteger { // 类型参数
  const C();
}

常规修复

#

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

dart
import 'dart:ffi';

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

abi_specific_integer_mapping_extra

#

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

说明

#

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

示例

#

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

dart
import 'dart:ffi';

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

常规修复

#

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

dart
import 'dart:ffi';

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

abi_specific_integer_mapping_missing

#

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

说明

#

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

示例

#

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

dart
import 'dart:ffi';

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

常规修复

#

向类添加 AbiSpecificIntegerMapping 注解：

dart
import 'dart:ffi';

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

abi_specific_integer_mapping_unsupported

#

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

说明

#

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

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

示例

#

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

dart
import 'dart:ffi';

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

常规修复

#

在映射中使用有效的类型之一作为值：

dart
import 'dart:ffi';

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

abstract_field_initializer

#

抽象字段不能有初始化器。

说明

#

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

示例

#

以下代码会生成此诊断信息，因为 f 被标记为 abstract 并具有初始化器：

dart
abstract class C {
  abstract int f = 0;
}

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

dart
abstract class C {
  abstract int f;

  C() : f = 0;
}

常规修复

#

如果字段必须是抽象的，则删除初始化器：

dart
abstract class C {
  abstract int f;
}

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

dart
abstract class C {
  int f = 0;
}

abstract_sealed_class

#

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

说明

#

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

示例

#

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

dart
abstract sealed class C {}

常规修复

#

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

dart
abstract class C {}

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

dart
sealed class C {}

abstract_super_member_reference

#

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

说明

#

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

示例

#

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

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

常规修复

#

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

ambiguous_export

#

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

说明

#

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

示例

#

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

dart
class C {}

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

dart
class C {}

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

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

常规修复

#

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

dart
export 'a.dart';

如果所有导出指令都是必需的，则隐藏除一个指令之外的所有指令中的名称：

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

ambiguous_extension_member_access

#

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

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

说明

#

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

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

示例

#

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

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

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

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

常规修复

#

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

如果您需要两者，则可以使用扩展重写显式选择要使用的扩展：

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

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

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

ambiguous_import

#

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

说明

#

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

示例

#

给定一个库（ a.dart ），它定义了一个类（在此示例中为 C ）：

dart
class A {}
class C {}

以及一个库（ b.dart ），它定义了具有相同名称的不同类：

dart
class B {}
class C {}

以下代码会生成此诊断信息：

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

void f(C c1, C c2) {}

常规修复

#

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

dart
import 'a.dart';

void f(C c1, C c2) {}

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

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

void f(C c1, C c2) {}

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

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

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

ambiguous_set_or_map_literal_both

#

该字面量不能同时是映射或集合，因为它至少包含一个字面量映射条目或一个展开运算符，该运算符展开一个'Map'，以及至少一个既不是这些的元素。

说明

#

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

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

示例

#

以下代码会生成此诊断信息：

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

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

常规修复

#

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

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

第二个修复方法是将一种类型的元素更改为与其他元素一致的元素。例如，您可以将列表的元素添加为映射到自身的键：

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

ambiguous_set_or_map_literal_either

#

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

说明

#

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

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

示例

#

以下代码会生成此诊断信息：

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

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

常规修复

#

解决此问题有三种常见方法。第一种方法是向字面量添加类型参数。例如，如果字面量旨在作为映射字面量，则您可以编写如下内容：

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

第二个修复方法是添加类型信息，以便表达式具有类型 Iterable 或类型 Map 。您可以添加显式强制转换，或者在这种情况下，向两个参数的声明添加类型：

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

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

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

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

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

您可以向 x 添加类型注解，如下所示：

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

annotation_on_pointer_field

#

类型为 'Pointer' 的结构体类中的字段不应该有任何注解。

说明

#

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

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

示例

#

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

dart
import 'dart:ffi';

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

常规修复

#

从字段中删除注解：

dart
import 'dart:ffi';

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

argument_must_be_a_constant

#

参数 '{0}' 必须是常量。

说明

#

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

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

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

示例

#

以下代码会生成此诊断信息，因为 isLeaf 参数的值是一个参数，因此不是常量：

dart
import 'dart:ffi';

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

常规修复

#

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

dart
import 'dart:ffi';

const isLeaf = false;

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

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

dart
import 'dart:ffi';

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

argument_must_be_native

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为传递给 addressOf 的参数是一个字符串，而不是一个字段，并且字符串不能被注解：

dart
import 'dart:ffi';

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

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

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

dart
import 'dart:ffi';

external void f();

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

常规修复

#

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

dart
import 'dart:ffi';

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

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

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

dart
import 'dart:ffi';

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

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

argument_type_not_assignable

#

参数类型 '{0}' 无法赋值给参数类型 '{1}'。{2}

说明

#

当参数的静态类型无法赋值给相应参数的静态类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 num 无法赋值给 String ：

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

常规修复

#

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

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

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

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

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

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

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

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

argument_type_not_assignable_to_error_handler

#

参数类型 '{0}' 无法赋值给参数类型 '{1} Function(Object)' 或 '{1} Function(Object, StackTrace)'。

说明

#

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

示例

#

以下代码会生成此诊断信息，因为传递给 catchError 的闭包不带任何参数，但该函数需要至少一个参数：

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

以下代码会生成此诊断信息，因为传递给 catchError 的闭包带三个参数，但它不能超过两个必需参数：

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

以下代码会生成此诊断信息，因为即使传递给 catchError 的闭包带有一个参数，该闭包也没有与 Object 兼容的类型：

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

常规修复

#

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

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

assert_in_redirecting_constructor

#

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

说明

#

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

示例

#

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

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

常规修复

#

如果不需要断言，则将其删除：

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

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

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

asset_directory_does_not_exist

#

资产目录 '{0}' 不存在。

说明

#

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

示例

#

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

yaml
name: example
flutter:
  assets:
    - assets/

常规修复

#

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

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

asset_does_not_exist

#

资产文件 '{0}' 不存在。

说明

#

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

示例

#

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

yaml
name: example
flutter:
  assets:
    - doesNotExist.gif

常规修复

#

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

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

asset_field_not_list

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为 assets 键的值是字符串，而预期的是列表：

yaml
name: example
flutter:
  assets: assets/

常规修复

#

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

yaml
name: example
flutter:
  assets:
    - assets/

asset_missing_path

#

资产映射条目必须包含 'path' 字段。

说明

#

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

示例

#

以下代码会生成此诊断信息，因为资产映射缺少 path 值：

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

常规修复

#

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

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

asset_not_string

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为 assets 列表包含一个映射：

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

常规修复

#

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

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

asset_not_string_or_map

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为资产值是一个列表：

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

常规修复

#

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

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

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

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

asset_path_not_string

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为资产映射包含一个列表作为 path 值：

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

常规修复

#

更改 asset 映射，使其包含一个字符串作为 path 值（有效的 POSIX 样式文件路径）：

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

assignment_of_do_not_store

#

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

说明

#

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

示例

#

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

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 1;

var x = f();

常规修复

#

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

assignment_to_const

#

常量变量不能赋值。

说明

#

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

示例

#

以下代码会生成此诊断信息，因为即使 c 具有 const 修饰符，它也被赋值：

dart
const c = 0;

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

常规修复

#

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

dart
var c = 0;

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

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

dart
const c = 0;

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

assignment_to_final

#

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

说明

#

当找到 setter 的调用，但由于具有相同名称的字段被声明为 final 或 const 而没有 setter 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 v 是 final：

dart
class C {
  final v = 0;
}

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

常规修复

#

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

dart
class C {
  int v = 0;
}

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

assignment_to_final_local

#

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

说明

#

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

示例

#

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

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

常规修复

#

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

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

assignment_to_final_no_setter

#

类 '{1}' 中没有名为 '{0}' 的 setter。

说明

#

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

示例

#

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

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

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

常规修复

#

如果您想调用现有的 setter，则更正名称：

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

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

如果您想调用 setter 但它还不存在，则声明它：

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

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

assignment_to_function

#

函数不能赋值。

说明

#

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

示例

#

以下代码会生成此诊断信息，因为对函数 f 的赋值无效：

dart
void f() {}

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

常规修复

#

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

dart
void f() {}

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

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

dart
void Function() f = () {};

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

assignment_to_method

#

方法不能赋值。

说明

#

当赋值的目标是方法时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 无法赋值，因为它是一个方法：

dart
class C {
  void f() {}

  void g() {
    f = null;
  }
}

常规修复

#

重写代码，使其不包含对方法的赋值。

assignment_to_type

#

类型不能赋值。

说明

#

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

示例

#

以下代码会生成此诊断信息，因为对类 C 的赋值无效：

dart
class C {}

void f() {
  C = null;
}

常规修复

#

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

dart
void f() {}

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

async_for_in_wrong_context

#

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

说明

#

当在主体没有标记为 async 或 async* 的函数或方法中找到异步 for-in 循环时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 的主体没有标记为 async 或 async* ，但 f 包含异步 for-in 循环：

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

常规修复

#

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

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

如果函数应该返回值的 Stream ，则用 async* 标记主体：

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

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

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

await_in_late_local_variable_initializer

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为在 v （标记为 late 的局部变量）的初始化器中使用了 await 表达式：

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

常规修复

#

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

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

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

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

await_of_incompatible_type

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为扩展类型 E 不是 Future 的子类：

dart
extension type E(int i) {}

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

常规修复

#

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

dart
extension type E(int i) {}

void f(E e) {
  e;
}

如果扩展类型旨在是可等待的，则向 implements 子句添加 Future （如果尚未添加 implements 子句，则添加一个），并使表示类型匹配：

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

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

body_might_complete_normally

#

主体可能正常完成，导致返回 'null'，但返回类型 '{0}' 是潜在的非空类型。

说明

#

当方法或函数的返回类型是 潜在的非空类型 ，但如果控制到达函数的末尾则会隐式返回 null 时，分析器会生成此诊断信息。

示例

#

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

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

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

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

常规修复

#

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

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

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

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

如果方法在末尾有意返回 null ，则在方法的末尾添加 null 的显式返回，并更改返回类型，以便返回 null 是有效的：

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

body_might_complete_normally_catch_error

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为传递给 catchError 方法的闭包需要返回一个 int ，但没有以显式 return 结束，导致它隐式返回 null ：

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

常规修复

#

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

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

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

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

body_might_complete_normally_nullable

#

此函数具有 '{0}' 的可空返回类型，但在没有返回值的情况下结束。

说明

#

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

示例

#

以下代码会生成此诊断信息，因为函数 f 隐式返回 null ：

dart
String? f() {}

常规修复

#

如果返回 null 是有意的，则使其显式：

dart
String? f() {
  return null;
}

如果函数应在此路径中返回非空值，则添加缺少的 return 语句：

dart
String? f() {
  return '';
}

break_label_on_switch_member

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为标签 l 与 0 的 case 子句关联：

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

常规修复

#

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

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

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

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

built_in_identifier_as_type

#

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

说明

#

当在需要类型名称的地方使用内置标识符时，分析器会生成此诊断信息。

示例

#

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

dart
import<int> x;

常规修复

#

用有效类型的名称替换内置标识符：

dart
List<int> x;

built_in_identifier_in_declaration

#

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

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

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

内置标识符 '{0}' 不能用作 typedef 名。

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

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为 mixin 是一个内置标识符：

dart
extension mixin on int {}

常规修复

#

为声明选择不同的名称。

case_block_not_terminated

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为 case 块以赋值结尾：

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

常规修复

#

添加必需的终止符之一：

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

case_expression_type_implements_equals

#

switch case 表达式类型 '{0}' 不能重写 '==' 运算符。

说明

#

当 case 关键字后的表达式的类型具有除 Object 中的运算符之外的 == 运算符的实现时，分析器会生成此诊断信息。

示例

#

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

dart
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 结构：

dart
class C {
  final int value;

  const C(this.value);

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

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

如果您无法重写 switch 语句并且不需要 == 的实现，则将其删除：

dart
class C {
  final int value;

  const C(this.value);
}

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

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

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

case_expression_type_is_not_switch_expression_subtype

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为 1 是 int ，它不是 String （ s 的类型）的子类型：

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

常规修复

#

如果 case 表达式的值错误，则更改 case 表达式，使其具有所需的类型：

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

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

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

cast_from_nullable_always_fails

#

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

说明

#

当具有可空类型的局部变量未赋值且强制转换为非空类型时，分析器会生成此诊断信息。因为变量未赋值，所以它具有 null 的默认值，这会导致强制转换引发异常。

示例

#

以下代码会生成此诊断信息，因为变量 x 在已知具有值 null 时被强制转换为非空类型（ int ）：

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

常规修复

#

如果预期变量在强制转换之前具有值，则添加初始化器或赋值：

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

如果不需要为变量赋值，则删除强制转换：

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

cast_from_null_always_fails

#

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

说明

#

当类型为 Null 的表达式强制转换为非空类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为已知 n 始终为 null ，但它被强制转换为非空类型：

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

常规修复

#

删除不必要的强制转换：

dart
void f(Null n) {
  n;
}

cast_to_non_type

#

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

说明

#

当强制转换表达式中的 as 后的名称被定义为非类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 是变量，而不是类型：

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

常规修复

#

用类型的名称替换名称：

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

class_used_as_mixin

#

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

说明

#

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

示例

#

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

dart
class M {}
class C with M {}

常规修复

#

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

dart
mixin M {}
class C with M {}

如果类需要同时是类和 mixin，则添加 mixin ：

dart
mixin class M {}
class C with M {}

collection_element_from_deferred_library

#

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

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

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

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

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

说明

#

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

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

示例

#

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

dart
const zero = 0;

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

dart
import 'a.dart' deferred as a;

var l = const [a.zero];

常规修复

#

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

dart
import 'a.dart' deferred as a;

var l = [a.zero];

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

dart
import 'a.dart' as a;

var l = const [a.zero];

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

dart
var l = const [0];

compound_implements_finalizable

#

类 '{0}' 不能实现 Finalizable。

说明

#

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

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

示例

#

以下代码会生成此诊断信息，因为类 S 实现 Finalizable ：

dart
import 'dart:ffi';

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

常规修复

#

尝试从类中删除 implements 子句：

dart
import 'dart:ffi';

final class S extends Struct {
  external Pointer notEmpty;
}

concrete_class_has_enum_superinterface

#

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

说明

#

当具体类间接地具有 Enum 类作为超接口时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为具体类 B 由于实现了 A 而具有 Enum 作为超接口：

dart
abstract class A implements Enum {}

class B implements A {}

常规修复

#

如果实现的类不是您打算实现的类，则更改它：

dart
abstract class A implements Enum {}

class B implements C {}

class C {}

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

dart
abstract class A {}

class B implements A {}

如果实现的类不能更改为不实现 Enum ，则将其从 implements 子句中删除：

dart
abstract class A implements Enum {}

class B {}

concrete_class_with_abstract_member

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为 m 是抽象方法，但 C 不是抽象类：

dart
class C {
  void m();
}

常规修复

#

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

dart
class C {
  void m() {}
}

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

dart
abstract class C {
  void m();
}

conflicting_constructor_and_static_member

#

' {0}' 不能同时用于命名此类中的构造函数和静态字段。

' {0}' 不能同时用于命名此类中的构造函数和静态 getter。

' {0}' 不能同时用于命名此类中的构造函数和静态方法。

' {0}' 不能同时用于命名此类中的构造函数和静态 setter。

说明

#

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

示例

#

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

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

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

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

常规修复

#

重命名成员或构造函数。

conflicting_generic_interfaces

#

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

说明

#

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

示例

#

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

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

常规修复

#

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

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

conflicting_type_variable_and_container

#

' {0}' 不能同时用于命名类型参数和定义类型参数的类。

' {0}' 不能同时用于命名类型参数和定义类型参数的枚举。

' {0}' 不能同时用于命名类型参数和定义类型参数的扩展。

' {0}' 不能同时用于命名类型参数和定义类型参数的扩展类型。

' {0}' 不能同时用于命名类型参数和定义类型参数的 mixin。

说明

#

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

示例

#

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

dart
class C<C> {}

常规修复

#

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

dart
class C<T> {}

conflicting_type_variable_and_member

#

' {0}' 不能同时用于命名类型参数和此类中的成员。

' {0}' 不能同时用于命名类型参数和此枚举中的成员。

' {0}' 不能同时用于命名类型参数和此扩展类型中的成员。

' {0}' 不能同时用于命名类型参数和此扩展中的成员。

' {0}' 不能同时用于命名类型参数和此 mixin 中的成员。

说明

#

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

示例

#

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

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

常规修复

#

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

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

constant_pattern_never_matches_value_type

#

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

说明

#

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

示例

#

以下代码会生成此诊断信息，因为常量模式 (true) 的类型是 bool ，而正在匹配的值（ x ）的类型是 int ，布尔值永远不可能匹配整数：

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

常规修复

#

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

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

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

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

constant_pattern_with_non_constant_expression

#

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

说明

#

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

示例

#

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

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

常规修复

#

如果应该匹配的值已知，则用该值替换表达式

用常量替换表达式：

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

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

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

const_constructor_param_type_mismatch

#

在 const 构造函数中，类型为 '{0}' 的值无法赋值给类型为 '{1}' 的参数。

说明

#

当常量值的运行时类型无法赋值给常量构造函数的参数的静态类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 i 的运行时类型是 int ，它无法赋值给 s 的静态类型：

dart
class C {
  final String s;

  const C(this.s);
}

const dynamic i = 0;

void f() {
  const C(i);
}

常规修复

#

将正确类型的值传递给构造函数：

dart
class C {
  final String s;

  const C(this.s);
}

const dynamic i = 0;

void f() {
  const C('$i');
}

const_constructor_with_field_initialized_by_non_const

#

无法定义 'const' 构造函数，因为字段 '{0}' 使用非常量值进行初始化。

说明

#

当构造函数具有关键字 const ，但类中的字段初始化为非常量值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 s 初始化为非常量值：

dart
String x = '3';
class C {
  final String s = x;
  const C();
}

常规修复

#

如果字段可以初始化为常量值，则将初始化器更改为常量表达式：

dart
class C {
  final String s = '3';
  const C();
}

如果字段不能初始化为常量值，则从构造函数中删除关键字 const ：

dart
String x = '3';
class C {
  final String s = x;
  C();
}

const_constructor_with_non_const_super

#

常量构造函数不能调用 '{0}' 的非常量超类构造函数。

说明

#

当标记为 const 的构造函数调用其超类中未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 B 中的 const 构造函数调用类 A 中的构造函数 nonConst ，并且超类构造函数不是 const 构造函数：

dart
class A {
  const A();
  A.nonConst();
}

class B extends A {
  const B() : super.nonConst();
}

常规修复

#

如果不需要调用当前正在调用的超类构造函数，则调用超类中的常量构造函数：

dart
class A {
  const A();
  A.nonConst();
}

class B extends A {
  const B() : super();
}

如果必须调用当前构造函数并且可以修改它，则向超类中的构造函数添加 const ：

dart
class A {
  const A();
  const A.nonConst();
}

class B extends A {
  const B() : super.nonConst();
}

如果必须调用当前构造函数并且无法修改它，则从子类中的构造函数中删除 const ：

dart
class A {
  const A();
  A.nonConst();
}

class B extends A {
  B() : super.nonConst();
}

const_constructor_with_non_final_field

#

无法为具有非 final 字段的类定义 const 构造函数。

说明

#

当构造函数被标记为 const 构造函数，但该构造函数在至少有一个非 final 实例字段（直接或通过继承）的类中定义时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 x 不是 final：

dart
class C {
  int x;

  const C(this.x) ;
}

常规修复

#

如果可以将所有字段标记为 final，则这样做：

dart
class C {
  final int x;

  const C(this.x);
}

如果无法将所有字段标记为 final，则从构造函数中删除关键字 const ：

dart
class C {
  int x;

  C(this.x);
}

const_deferred_class

#

延迟加载类不能用 'const' 创建。

说明

#

当使用延迟导入导入的库中的类用于创建 const 对象时，分析器会生成此诊断信息。常量在编译时计算，而来自延迟加载库的类在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为它尝试从延迟加载库创建类的 const 实例：

dart
import 'dart:convert' deferred as convert;

const json2 = convert.JsonCodec();

常规修复

#

如果对象不需要是常量，则更改代码以创建非常量实例：

dart
import 'dart:convert' deferred as convert;

final json2 = convert.JsonCodec();

如果对象必须是常量，则从导入指令中删除 deferred ：

dart
import 'dart:convert' as convert;

const json2 = convert.JsonCodec();

const_initialized_with_non_constant_value

#

常量变量必须用常量值初始化。

说明

#

当静态已知不是常量的值被赋值给声明为 const 变量的变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 没有声明为 const ：

dart
var x = 0;
const y = x;

常规修复

#

如果被赋值的值可以声明为 const ，则更改声明：

dart
const x = 0;
const y = x;

如果该值不能声明为 const ，则从变量中删除 const 修饰符，可能使用 final 代替：

dart
var x = 0;
final y = x;

const_initialized_with_non_constant_value_from_deferred_library

#

来自延迟加载库的常量值不能用于初始化 'const' 变量。

说明

#

当 const 变量使用来自使用延迟导入导入的库的 const 变量初始化时，分析器会生成此诊断信息。常量在编译时计算，而来自延迟加载库的值在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为变量 pi 使用来自库 dart:math 的常量 math.pi 进行初始化，并且 dart:math 被导入为延迟加载库：

dart
import 'dart:math' deferred as math;

const pi = math.pi;

常规修复

#

如果您需要引用导入库中常量的值，则删除关键字 deferred ：

dart
import 'dart:math' as math;

const pi = math.pi;

如果您不需要引用导入的常量，则删除引用：

dart
const pi = 3.14;

const_instance_field

#

只有静态字段才能声明为 const。

说明

#

当实例字段被标记为 const 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是实例字段：

dart
class C {
  const int f = 3;
}

常规修复

#

如果字段需要是实例字段，则删除关键字 const ，或将其替换为 final ：

dart
class C {
  final int f = 3;
}

如果字段确实应该是 const 字段，则将其设为静态字段：

dart
class C {
  static const int f = 3;
}

const_map_key_not_primitive_equality

#

常量映射中键的类型不能重写 '==' 运算符或 'hashCode'，但类 '{0}' 重写了。

说明

#

当用作常量映射字面量中键的对象的类实现 == 运算符、getter hashCode 或两者时，分析器会生成此诊断信息。常量映射的实现使用 == 运算符和 hashCode getter，因此除从 Object 继承的实现之外的任何实现都需要在编译时执行任意代码，这是不受支持的。

示例

#

以下代码会生成此诊断信息，因为常量映射包含一个键，其类型为 C ，并且类 C 重写了 == 的实现：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

const map = {C() : 0};

以下代码会生成此诊断信息，因为常量映射包含一个键，其类型为 C ，并且类 C 重写了 hashCode 的实现：

dart
class C {
  const C();

  int get hashCode => 3;
}

const map = {C() : 0};

常规修复

#

如果您可以从类中删除 == 和 hashCode 的实现，则这样做：

dart
class C {
  const C();
}

const map = {C() : 0};

如果您无法从类中删除 == 和 hashCode 的实现，则使映射非常量：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

final map = {C() : 0};

const_not_initialized

#

常量 '{0}' 必须初始化。

说明

#

当声明为常量的变量没有初始化器时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 c 未初始化：

dart
const c;

常规修复

#

添加初始化器：

dart
const c = 'c';

const_set_element_not_primitive_equality

#

(以前称为 const_set_element_type_implements_equals)

常量集合中的元素不能重写 '==' 运算符或 'hashCode'，但类型 '{0}' 重写了。

说明

#

当用作常量集合字面量中元素的对象的类实现 == 运算符、getter hashCode 或两者时，分析器会生成此诊断信息。常量集合的实现使用 == 运算符和 hashCode getter，因此除从 Object 继承的实现之外的任何实现都需要在编译时执行任意代码，这是不受支持的。

示例

#

以下代码会生成此诊断信息，因为常量集合包含一个元素，其类型为 C ，并且类 C 重写了 == 的实现：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

const set = {C()};

以下代码会生成此诊断信息，因为常量集合包含一个元素，其类型为 C ，并且类 C 重写了 hashCode 的实现：

dart
class C {
  const C();

  int get hashCode => 3;
}

const map = {C()};

常规修复

#

如果您可以从类中删除 == 和 hashCode 的实现，则这样做：

dart
class C {
  const C();
}

const set = {C()};

如果您无法从类中删除 == 和 hashCode 的实现，则使集合非常量：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

final set = {C()};

const_spread_expected_list_or_set

#

在此展开中预期列表或集合。

说明

#

当常量列表或集合中展开运算符的表达式计算结果不是列表或集合时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 list1 的值为 null ，它既不是列表也不是集合：

dart
const dynamic list1 = 42;
const List<int> list2 = [...list1];

常规修复

#

将表达式更改为计算结果为常量列表或常量集合的内容：

dart
const dynamic list1 = [42];
const List<int> list2 = [...list1];

const_spread_expected_map

#

用常量替换表达式：

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

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

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

const_constructor_param_type_mismatch

#

在 const 构造函数中，类型为 '{0}' 的值无法赋值给类型为 '{1}' 的参数。

说明

#

当常量值的运行时类型无法赋值给常量构造函数的参数的静态类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 i 的运行时类型是 int ，它无法赋值给 s 的静态类型：

dart
class C {
  final String s;

  const C(this.s);
}

const dynamic i = 0;

void f() {
  const C(i);
}

常规修复

#

将正确类型的值传递给构造函数：

dart
class C {
  final String s;

  const C(this.s);
}

const dynamic i = 0;

void f() {
  const C('$i');
}

const_constructor_with_field_initialized_by_non_const

#

无法定义 'const' 构造函数，因为字段 '{0}' 使用非常量值进行初始化。

说明

#

当构造函数具有关键字 const ，但类中的字段初始化为非常量值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 s 初始化为非常量值：

dart
String x = '3';
class C {
  final String s = x;
  const C();
}

常规修复

#

如果字段可以初始化为常量值，则将初始化器更改为常量表达式：

dart
class C {
  final String s = '3';
  const C();
}

如果字段不能初始化为常量值，则从构造函数中删除关键字 const ：

dart
String x = '3';
class C {
  final String s = x;
  C();
}

const_constructor_with_non_const_super

#

常量构造函数不能调用 '{0}' 的非常量超类构造函数。

说明

#

当标记为 const 的构造函数调用其超类中未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 B 中的 const 构造函数调用类 A 中的构造函数 nonConst ，并且超类构造函数不是 const 构造函数：

dart
class A {
  const A();
  A.nonConst();
}

class B extends A {
  const B() : super.nonConst();
}

常规修复

#

如果不需要调用当前正在调用的超类构造函数，则调用超类中的常量构造函数：

dart
class A {
  const A();
  A.nonConst();
}

class B extends A {
  const B() : super();
}

如果必须调用当前构造函数并且可以修改它，则向超类中的构造函数添加 const ：

dart
class A {
  const A();
  const A.nonConst();
}

class B extends A {
  const B() : super.nonConst();
}

如果必须调用当前构造函数并且无法修改它，则从子类中的构造函数中删除 const ：

dart
class A {
  const A();
  A.nonConst();
}

class B extends A {
  B() : super.nonConst();
}

const_constructor_with_non_final_field

#

无法为具有非 final 字段的类定义 const 构造函数。

说明

#

当构造函数被标记为 const 构造函数，但该构造函数在至少有一个非 final 实例字段（直接或通过继承）的类中定义时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 x 不是 final：

dart
class C {
  int x;

  const C(this.x) ;
}

常规修复

#

如果可以将所有字段标记为 final，则这样做：

dart
class C {
  final int x;

  const C(this.x);
}

如果无法将所有字段标记为 final，则从构造函数中删除关键字 const ：

dart
class C {
  int x;

  C(this.x);
}

const_deferred_class

#

延迟加载类不能用 'const' 创建。

说明

#

当使用延迟导入导入的库中的类用于创建 const 对象时，分析器会生成此诊断信息。常量在编译时计算，而来自延迟加载库的类在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为它尝试从延迟加载库创建类的 const 实例：

dart
import 'dart:convert' deferred as convert;

const json2 = convert.JsonCodec();

常规修复

#

如果对象不需要是常量，则更改代码以创建非常量实例：

dart
import 'dart:convert' deferred as convert;

final json2 = convert.JsonCodec();

如果对象必须是常量，则从导入指令中删除 deferred ：

dart
import 'dart:convert' as convert;

const json2 = convert.JsonCodec();

const_initialized_with_non_constant_value

#

常量变量必须用常量值初始化。

说明

#

当静态已知不是常量的值被赋值给声明为 const 变量的变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 没有声明为 const ：

dart
var x = 0;
const y = x;

常规修复

#

如果被赋值的值可以声明为 const ，则更改声明：

dart
const x = 0;
const y = x;

如果该值不能声明为 const ，则从变量中删除 const 修饰符，可能使用 final 代替：

dart
var x = 0;
final y = x;

const_initialized_with_non_constant_value_from_deferred_library

#

来自延迟加载库的常量值不能用于初始化 'const' 变量。

说明

#

当 const 变量使用来自使用延迟导入导入的库的 const 变量初始化时，分析器会生成此诊断信息。常量在编译时计算，而来自延迟加载库的值在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为变量 pi 使用来自库 dart:math 的常量 math.pi 进行初始化，并且 dart:math 被导入为延迟加载库：

dart
import 'dart:math' deferred as math;

const pi = math.pi;

常规修复

#

如果您需要引用导入库中常量的值，则删除关键字 deferred ：

dart
import 'dart:math' as math;

const pi = math.pi;

如果您不需要引用导入的常量，则删除引用：

dart
const pi = 3.14;

const_instance_field

#

只有静态字段才能声明为 const。

说明

#

当实例字段被标记为 const 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是实例字段：

dart
class C {
  const int f = 3;
}

常规修复

#

如果字段需要是实例字段，则删除关键字 const ，或将其替换为 final ：

dart
class C {
  final int f = 3;
}

如果字段确实应该是 const 字段，则将其设为静态字段：

dart
class C {
  static const int f = 3;
}

const_map_key_not_primitive_equality

#

常量映射中键的类型不能重写 '==' 运算符或 'hashCode'，但类 '{0}' 重写了。

说明

#

当用作常量映射字面量中键的对象的类实现 == 运算符、getter hashCode 或两者时，分析器会生成此诊断信息。常量映射的实现使用 == 运算符和 hashCode getter，因此除从 Object 继承的实现之外的任何实现都需要在编译时执行任意代码，这是不受支持的。

示例

#

以下代码会生成此诊断信息，因为常量映射包含一个键，其类型为 C ，并且类 C 重写了 == 的实现：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

const map = {C() : 0};

以下代码会生成此诊断信息，因为常量映射包含一个键，其类型为 C ，并且类 C 重写了 hashCode 的实现：

dart
class C {
  const C();

  int get hashCode => 3;
}

const map = {C() : 0};

常规修复

#

如果您可以从类中删除 == 和 hashCode 的实现，则这样做：

dart
class C {
  const C();
}

const map = {C() : 0};

如果您无法从类中删除 == 和 hashCode 的实现，则使映射非常量：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

final map = {C() : 0};

const_not_initialized

#

常量 '{0}' 必须初始化。

说明

#

当声明为常量的变量没有初始化器时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 c 未初始化：

dart
const c;

常规修复

#

添加初始化器：

dart
const c = 'c';

const_set_element_not_primitive_equality

#

(以前称为 const_set_element_type_implements_equals)

常量集合中的元素不能重写 '==' 运算符或 'hashCode'，但类型 '{0}' 重写了。

说明

#

当用作常量集合字面量中元素的对象的类实现 == 运算符、getter hashCode 或两者时，分析器会生成此诊断信息。常量集合的实现使用 == 运算符和 hashCode getter，因此除从 Object 继承的实现之外的任何实现都需要在编译时执行任意代码，这是不受支持的。

示例

#

以下代码会生成此诊断信息，因为常量集合包含一个元素，其类型为 C ，并且类 C 重写了 == 的实现：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

const set = {C()};

以下代码会生成此诊断信息，因为常量集合包含一个元素，其类型为 C ，并且类 C 重写了 hashCode 的实现：

dart
class C {
  const C();

  int get hashCode => 3;
}

const map = {C()};

常规修复

#

如果您可以从类中删除 == 和 hashCode 的实现，则这样做：

dart
class C {
  const C();
}

const set = {C()};

如果您无法从类中删除 == 和 hashCode 的实现，则使集合非常量：

dart
class C {
  const C();

  bool operator ==(Object other) => true;
}

final set = {C()};

const_spread_expected_list_or_set

#

在此展开中预期列表或集合。

说明

#

当常量列表或集合中展开运算符的表达式计算结果不是列表或集合时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 list1 的值为 null ，它既不是列表也不是集合：

dart
const dynamic list1 = 42;
const List<int> list2 = [...list1];

常规修复

#

将表达式更改为计算结果为常量列表或常量集合的内容：

dart
const dynamic list1 = [42];
const List<int> list2 = [...list1];

const_spread_expected_map

#

在此展开中预期映射。

说明

#

当常量映射中展开运算符的表达式计算结果不是映射时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 map1 的值为 null ，它不是映射：

dart
const dynamic map1 = 42;
const Map<String, int> map2 = {...map1};

常规修复

#

将表达式更改为计算结果为常量映射的内容：

dart
const dynamic map1 = {'answer': 42};
const Map<String, int> map2 = {...map1};

const_with_non_const

#

正在调用的构造函数不是 const 构造函数。

说明

#

当使用关键字 const 调用未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

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

dart
class A {
  A();
}

A f() => const A();

常规修复

#

如果可以并且需要将类设为常量类（通过使类的所有字段，包括继承的字段，都为 final），则向构造函数添加关键字 const ：

dart
class A {
  const A();
}

A f() => const A();

否则，删除关键字 const ：

dart
class A {
  A();
}

A f() => A();

const_with_non_constant_argument

#

常量创建的参数必须是常量表达式。

说明

#

当使用不是常量表达式的参数调用 const 构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 i 不是常量：

dart
class C {
  final int i;
  const C(this.i);
}
C f(int i) => const C(i);

常规修复

#

使所有参数都成为常量表达式，或者删除 const 关键字以使用构造函数的非常量形式：

dart
class C {
  final int i;
  const C(this.i);
}
C f(int i) => C(i);

const_with_type_parameters

#

常量构造函数 tearoff 不能使用类型参数作为类型参数。

常量创建不能使用类型参数作为类型参数。

常量函数 tearoff 不能使用类型参数作为类型参数。

说明

#

当在构造函数的 const 调用中使用类型参数作为类型参数时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值（运行时将使用的实际类型）在编译时无法知道。

示例

#

以下代码会生成此诊断信息，因为在创建常量时使用类型参数 T 作为类型参数：

dart
class C<T> {
  const C();
}

C<T> newC<T>() => const C<T>();

常规修复

#

如果可以在编译时知道将用于类型参数的类型，则删除类型参数的使用：

dart
class C<T> {
  const C();
}

C<int> newC() => const C<int>();

如果直到运行时才能知道将用于类型参数的类型，则删除关键字 const ：

dart
class C<T> {
  const C();
}

C<T> newC<T>() => C<T>();

continue_label_invalid

#

(以前称为 continue_label_on_switch)

'continue' 语句中使用的标签必须在循环或 switch 成员上定义。

说明

#

当 continue 语句中的标签解析为 switch 语句上的标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为用于标记 switch 语句的标签 l 用于 continue 语句中：

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

常规修复

#

找到实现所需控制流的不同方法；例如，通过引入重新执行 switch 语句的循环。

creation_of_struct_or_union

#

'Struct' 和 'Union' 的子类由本机内存支持，不能通过生成式构造函数实例化。

说明

#

当使用生成式构造函数实例化 Struct 或 Union 的子类时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为类 C 使用生成式构造函数进行实例化：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int32()
  external int a;
}

void f() {
  C() ;
}

常规修复

#

如果您需要分配类描述的结构，则使用 ffi 包来执行此操作：

dart
import 'dart:ffi';
import 'package:ffi/ffi.dart';

final class C extends Struct {
  @Int32()
  external int a;
}

void f() {
  final pointer = calloc.allocate<C>(4);
  final c = pointer.ref;
  print(c);
  calloc.free(pointer);
}

creation_with_non_type

#

名称 '{0}' 不是类。

说明

#

当使用 new 或 const 的实例创建指定未定义为类的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是函数而不是类：

dart
int f() => 0;

void g() {
  new f() ;
}

常规修复

#

如果应该创建类，则用有效类的名称替换无效名称：

dart
int f() => 0;

void g() {
  new Object();
}

如果名称是函数的名称，并且您希望调用该函数，则删除 new 或 const 关键字：

dart
int f() => 0;

void g() {
  f();
}

dead_code

#

无效代码。

无效代码：被赋值的通配符变量被标记为 late，并且永远不会被引用，因此此初始化器将永远不会被计算。

说明

#

当找到不会执行的代码时，分析器会生成此诊断信息，因为执行永远不会到达该代码。

示例

#

以下代码会生成此诊断信息，因为 print 的调用发生在函数返回之后：

dart
void f() {
  return;
  print('here');
}

常规修复

#

如果不需要代码，则将其删除：

dart
void f() {
  return;
}

如果需要执行代码，则将其移动到将执行它的位置：

dart
void f() {
  print('here');
  return;
}

或者，重写之前的代码，以便可以到达它：

dart
void f({bool skipPrinting = true}) {
  if (skipPrinting) {
    return;
  }
  print('here');
}

dead_code_catch_following_catch

#

无效代码：在 'catch (e)' 或 'on Object catch (e)' 之后的 catch 子句永远不会到达。

说明

#

当找到无法执行的 catch 子句时，分析器会生成此诊断信息，因为它位于 catch (e) 或 on Object catch (e) 形式的 catch 子句之后。将选择第一个与抛出的对象匹配的 catch 子句，并且这两种形式都将匹配任何对象，因此不会选择跟在它们后面的 catch 子句。

示例

#

以下代码会生成此诊断信息：

dart
void f() {
  try {
  } catch (e) {
  } on String {
  }
}

常规修复

#

如果应选择该子句，则将其移动到一般子句之前：

dart
void f() {
  try {
  } on String {
  } catch (e) {
  }
}

如果不需要选择该子句，则将其删除：

dart
void f() {
  try {
  } catch (e) {
  }
}

dead_code_on_catch_subtype

#

无效代码：此 on-catch 块不会执行，因为 '{0}' 是 '{1}' 的子类型，因此已经被捕获了。

说明

#

当找到无法执行的 catch 子句时，分析器会生成此诊断信息，因为它位于捕获相同类型或其超类型的 catch 子句之后。将选择第一个与抛出的对象匹配的 catch 子句，并且较早的子句始终匹配突出显示的子句可以匹配的任何内容，因此永远不会选择突出显示的子句。

示例

#

以下代码会生成此诊断信息：

dart
void f() {
  try {
  } on num {
  } on int {
  }
}

常规修复

#

如果应选择该子句，则将其移动到一般子句之前：

dart
void f() {
  try {
  } on int {
  } on num {
  }
}

如果不需要选择该子句，则将其删除：

dart
void f() {
  try {
  } on num {
  }
}

dead_null_aware_expression

#

左操作数不能为 null，因此从不执行右操作数。

说明

#

分析器在两种情况下会生成此诊断信息。

第一种情况是 ?? 运算符的左操作数不能为 null 。只有当左操作数的值为 null 时才计算右操作数，因为左操作数不能为 null ，所以从不计算右操作数。

第二种情况是使用 ??= 运算符的赋值的左侧不能为 null 。只有当左侧的值为 null 时才计算右侧，因为左侧不能为 null ，所以从不计算右侧。

示例

#

以下代码会生成此诊断信息，因为 x 不能为 null ：

dart
int f(int x) {
  return x ?? 0;
}

以下代码会生成此诊断信息，因为 f 不能为 null ：

dart
class C {
  int f = -1;

  void m(int x) {
    f ??= x;
  }
}

常规修复

#

如果诊断是针对 ?? 运算符报告的，则删除 ?? 运算符和右操作数：

dart
int f(int x) {
  return x;
}

如果诊断是针对赋值报告的，并且不需要赋值，则删除赋值：

dart
class C {
  int f = -1;

  void m(int x) {
  }
}

如果需要赋值，但应基于不同的条件，则重写代码以使用 = 和不同的条件：

dart
class C {
  int f = -1;

  void m(int x) {
    if (f < 0) {
      f = x;
    }
  }
}

default_list_constructor

#

'List' 的默认构造函数在启用空安全时不可用。

说明

#

当在已启用空安全的代码中找到对 List 类的默认构造函数的使用时，分析器会生成此诊断信息。

示例

#

假设以下代码已启用空安全，它会生成此诊断信息，因为它使用了默认的 List 构造函数：

dart
var l = List<int>() ;

常规修复

#

如果没有提供初始大小，则将代码转换为使用列表字面量：

dart
var l = <int>[];

如果需要提供初始大小并且元素只有一个合理的初始值，则使用 List.filled ：

dart
var l = List.filled(3, 0);

如果需要提供初始大小，但需要计算每个元素，则使用 List.generate ：

dart
var l = List.generate(3, (i) => i);

default_value_in_function_type

#

函数类型中的参数不能具有默认值。

说明

#

当与参数关联的函数类型包含具有默认值的可选参数时，分析器会生成此诊断信息。这是不允许的，因为参数的默认值不是函数类型的一部分，因此包含它们没有任何价值。

示例

#

以下代码会生成此诊断信息，因为参数 p 具有默认值，即使它是参数 g 的类型的一部分：

dart
void f(void Function([int p = 0]) g) {
}

常规修复

#

从函数类型的参数中删除默认值：

dart
void f(void Function([int p]) g) {
}

default_value_in_redirecting_factory_constructor

#

重定向到另一个构造函数的工厂构造函数中不允许使用默认值。

说明

#

当重定向到另一个构造函数的工厂构造函数包含具有默认值的参数时，分析器会生成此诊断信息。

重定向到另一个构造函数的工厂构造函数为可选参数指定默认值。

示例

#

以下代码会生成此诊断信息，因为 A 中的工厂构造函数为可选参数 x 提供了默认值：

dart
class A {
  factory A([int x = 0]) = B;
}

class B implements A {
  B([int x = 1]) {}
}

常规修复

#

从工厂构造函数中删除默认值：

dart
class A {
  factory A([int x]) = B;
}

class B implements A {
  B([int x = 1]) {}
}

请注意，此修复可能会更改省略可选参数时使用的值。如果发生这种情况，并且此更改是一个问题，则考虑在工厂方法中将可选参数设为必需参数：

dart
class A {
 factory A(int x) = B;
}

class B implements A {
  B([int x = 1]) {}
}

default_value_on_required_parameter

#

必需的命名参数不能有默认值。

说明

#

当命名参数同时具有 required 修饰符和默认值时，分析器会生成此诊断信息。如果参数是必需的，则在调用站点始终提供参数的值，因此永远不会使用默认值。

示例

#

以下代码会生成此诊断信息：

dart
void log({required String message = 'no message'}) {}

常规修复

#

如果参数确实是必需的，则删除默认值：

dart
void log({required String message}) {}

如果参数并非总是必需的，则删除 required 修饰符：

dart
void log({String message = 'no message'}) {}

deferred_import_of_extension

#

延迟加载库的导入必须隐藏所有扩展。

说明

#

当使用延迟导入导入的库声明在导入库中可见的扩展时，分析器会生成此诊断信息。扩展方法在编译时解析，而来自延迟加载库的扩展在编译时不可用。

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

示例

#

给定一个定义命名扩展的文件 a.dart ：

dart
class C {}

extension E on String {
  int get size => length;
}

以下代码会生成此诊断信息，因为命名扩展对库可见：

dart
import 'a.dart' deferred as a;

void f() {
  a.C();
}

常规修复

#

如果库必须作为 deferred 导入，则添加一个 show 子句列出被引用的名称，或者添加一个 hide 子句列出所有命名扩展。添加 show 子句如下所示：

dart
import 'a.dart' deferred as a show C;

void f() {
  a.C();
}

添加 hide 子句如下所示：

dart
import 'a.dart' deferred as a hide E;

void f() {
  a.C();
}

对于第一个修复，好处是如果向导入的库添加了新的扩展，则这些扩展不会导致生成诊断信息。

如果库不需要作为 deferred 导入，或者如果您需要使用其中声明的扩展方法，则删除关键字 deferred ：

dart
import 'a.dart' as a;

void f() {
  a.C();
}

definitely_unassigned_late_local_variable

#

在此处，late 局部变量 '{0}' 肯定未赋值。

说明

#

当 明确赋值 分析显示标记为 late 的局部变量在赋值之前被读取时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为在读取 x 之前没有为其赋值：

dart
void f(bool b) {
  late int x;
  print(x);
}

常规修复

#

在读取变量之前为其赋值：

dart
void f(bool b) {
  late int x;
  x = b ? 1 : 0;
  print(x);
}

dependencies_field_not_map

#

' {0}' 字段的值应为映射。

说明

#

当 dependencies 或 dev_dependencies 键的值不是映射时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级 dependencies 键的值是一个列表：

yaml
name: example
dependencies:
  - meta

常规修复

#

使用映射作为 dependencies 键的值：

yaml
name: example
dependencies:
  meta: ^1.0.2

deprecated_colon_for_default_value

#

使用冒号作为默认值之前的分隔符已弃用，并且在语言版本 3.0 及更高版本中将不受支持。

说明

#

当冒号（ : ）用作可选命名参数的默认值之前的分隔符时，分析器会生成此诊断信息。虽然此语法允许，但它已被弃用，建议使用等号（ = ）。

示例

#

以下代码会生成此诊断信息，因为在可选参数 i 的默认值之前使用了冒号：

dart
void f({int i : 0}) {}

常规修复

#

将冒号替换为等号。

dart
void f({int i = 0}) {}

deprecated_export_use

#

间接导入 '{0}' 的功能已弃用。

说明

#

当一个库从第二个库导入名称，并且第二个库从第三个库导出名称，但已指出将来不会导出第三个库时，分析器会生成此诊断信息。

示例

#

给定一个定义类 A 的库 a.dart ：

dart
class A {}

以及一个导出 a.dart 但已将导出标记为已弃用的第二个库 b.dart ：

dart
import 'a.dart';

@deprecated
export 'a.dart';

以下代码会生成此诊断信息，因为在将来的某个版本中，类 A 将不会从 b.dart 导出：

dart
import 'b.dart';

A? a;

常规修复

#

如果名称可从您可以导入的不同库中获得，则将现有导入替换为该库的导入（如果您仍然需要旧导入，则添加定义库的导入）：

dart
import 'a.dart';

A? a;

如果名称不可用，则查找库作者的说明或直接联系他们以了解如何更新您的代码。

deprecated_field

#

' {0}' 字段不再使用，可以删除。

说明

#

当在 pubspec.yaml 文件中使用已弃用的键时，分析器会生成此诊断信息。未使用的键会占用空间，并且可能暗示不再有效的语义。

示例

#

以下代码会生成此诊断信息，因为 author 键不再使用：

dart
name: example
author: 'Dash'

常规修复

#

删除已弃用的键：

dart
name: example

deprecated_member_use

#

' {0}' 已弃用，不应使用。

' {0}' 已弃用，不应使用。{1}

说明

#

当在不同的包中使用已弃用的库或类成员时，分析器会生成此诊断信息。

示例

#

如果类 C 中的方法 m 用 @deprecated 进行注释，则以下代码会生成此诊断信息：

dart
void f(C c) {
  c. m() ;
}

常规修复

#

用 @deprecated 注释的声明的文档应该指出要使用哪些代码来代替已弃用的代码。

deprecated_member_use_from_same_package

#

' {0}' 已弃用，不应使用。

' {0}' 已弃用，不应使用。{1}

说明

#

当在声明它的同一个包中使用已弃用的库成员或类成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 已弃用：

dart
@deprecated
var x = 0;
var y = x;

常规修复

#

修复取决于已弃用的内容和替换内容。已弃用声明的文档应指出要使用哪些代码来代替已弃用的代码。

deprecated_new_in_comment_reference

#

在注释引用中使用 'new' 关键字已弃用。

说明

#

当注释引用（文档注释中方括号中声明的名称）使用关键字 new 来引用构造函数时，分析器会生成此诊断信息。此形式已弃用。

示例

#

以下代码会生成此诊断信息，因为未命名构造函数使用 new C 进行引用：

dart
/// See [new C].
class C {
  C();
}

以下代码会生成此诊断信息，因为名为 c 的构造函数使用 new C.c 进行引用：

dart
/// See [new C.c].
class C {
  C.c();
}

常规修复

#

如果您正在引用命名构造函数，则删除关键字 new ：

dart
/// See [C.c].
class C {
  C.c();
}

如果您正在引用未命名构造函数，则删除关键字 new 并将 .new 附加到类名之后：

dart
/// See [C.new].
class C {
  C.c();
}

deprecated_subtype_of_function

#

扩展 'Function' 已弃用。

实现 'Function' 没有效果。

混合 'Function' 已弃用。

说明

#

当在类的 extends 、 implements 或 with 子句中使用类 Function 时，分析器会生成此诊断信息。以这种方式使用类 Function 没有语义值，因此它实际上是无效代码。

示例

#

以下代码会生成此诊断信息，因为 Function 用作 F 的超类：

dart
class F extends Function {}

常规修复

#

从它所在的任何子句中删除类 Function ，如果 Function 是子句中唯一的类型，则删除整个子句：

dart
class F {}

disallowed_type_instantiation_expression

#

只有泛型类型、泛型函数、泛型实例方法或泛型构造函数才能具有类型参数。

说明

#

当具有除允许的几种值类型之外的值的表达式后跟类型参数时，分析器会生成此诊断信息。允许的值类型包括：

  • 泛型类型，
  • 泛型构造函数，以及
  • 泛型函数，包括顶级函数、静态和实例成员以及局部函数。

示例

#

以下代码会生成此诊断信息，因为 i 是顶级变量，它不是允许的情况之一：

dart
int i = 1;

void f() {
  print(i<int>);
}

常规修复

#

如果引用的值正确，则删除类型参数：

dart
int i = 1;

void f() {
  print(i);
}

division_optimization

#

运算符 x ~/ y 比 (x / y).toInt() 更有效。

说明

#

当使用 toInt 将两个数字相除的结果转换为整数时，分析器会生成此诊断信息。Dart 有一个内置的整数除法运算符，它既更高效又更简洁。

示例

#

以下代码会生成此诊断信息，因为使用 toInt 将 x 和 y 相除的结果转换为整数：

dart
int divide(int x, int y) => (x / y).toInt();

常规修复

#

使用整数除法运算符（ ~/ ）：

dart
int divide(int x, int y) => x ~/ y;

duplicate_constructor

#

名为 '{0}' 的构造函数已定义。

未命名构造函数已定义。

说明

#

当类声明多个未命名构造函数或声明多个具有相同名称的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为有两个未命名构造函数的声明：

dart
class C {
  C();

  C() ;
}

以下代码会生成此诊断信息，因为有两个名为 m 的构造函数的声明：

dart
class C {
  C.m();

  C.m() ;
}

常规修复

#

如果有多个未命名构造函数并且所有构造函数都是必需的，则为所有构造函数或除一个构造函数之外的所有构造函数命名：

dart
class C {
  C();

  C.n();
}

如果有多个未命名构造函数并且除一个构造函数之外的所有构造函数都是不需要的，则删除不需要的构造函数：

dart
class C {
  C();
}

如果有多个命名构造函数并且所有构造函数都是必需的，则重命名除一个构造函数之外的所有构造函数：

dart
class C {
  C.m();

  C.n();
}

如果有多个命名构造函数并且除一个构造函数之外的所有构造函数都是不需要的，则删除不需要的构造函数：

dart
class C {
  C.m();
}

duplicate_definition

#

名称 '{0}' 已定义。

说明

#

当声明名称时，并且在相同作用域中存在先前声明的相同名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 x 被声明了两次：

dart
int x = 0;
int x = 1;

常规修复

#

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

dart
int x = 0;
int y = 1;

duplicate_export

#

重复导出。

说明

#

当找到与文件前面导出的导出相同的导出指令时，分析器会生成此诊断信息。第二个导出不会增加价值，应将其删除。

示例

#

以下代码会生成此诊断信息，因为同一个库被导出了两次：

dart
export 'package:meta/meta.dart';
export 'package:meta/meta.dart';

常规修复

#

删除不必要的导出：

dart
export 'package:meta/meta.dart';

duplicate_field_formal_parameter

#

字段 '{0}' 不能由同一个构造函数中的多个参数初始化。

说明

#

当构造函数的参数列表中存在多个用于同一字段的初始化形式参数时，分析器会生成此诊断信息。赋值一个将立即被覆盖的值是没有用的。

示例

#

以下代码会生成此诊断信息，因为 this.f 在参数列表中出现了两次：

dart
class C {
  int f;

  C(this.f, this.f) {}
}

常规修复

#

删除其中一个初始化形式参数：

dart
class C {
  int f;

  C(this.f) {}
}

duplicate_field_name

#

字段名 '{0}' 已在此记录中使用。

说明

#

当记录字面量或记录类型注解包含一个字段时，分析器会生成此诊断信息，该字段的名称与相同字面量或类型中先前声明的字段的名称相同。

示例

#

以下代码会生成此诊断信息，因为记录字面量有两个名为 a 的字段：

dart
var r = (a: 1, a: 2);

以下代码会生成此诊断信息，因为记录类型注解有两个名为 a 的字段，一个是位置字段，另一个是命名字段：

dart
void f((int a, {int a}) r) {}

常规修复

#

重命名一个或两个字段：

dart
var r = (a: 1, b: 2);

duplicate_hidden_name

#

重复隐藏的名称。

说明

#

当名称在 hide 子句中多次出现时，分析器会生成此诊断信息。重复名称是不必要的。

示例

#

以下代码会生成此诊断信息，因为名称 min 被隐藏了多次：

dart
import 'dart:math' hide min, min;

var x = pi;

常规修复

#

如果在一个或多个地方拼写错误的名称，则更正拼写错误的名称：

dart
import 'dart:math' hide max, min;

var x = pi;

如果名称没有拼写错误，则从列表中删除不必要的名称：

dart
import 'dart:math' hide min;

var x = pi;

duplicate_ignore

#

不需要在此处忽略诊断 '{0}'，因为它已被忽略。

说明

#

当诊断名称出现在 ignore 注释中，但诊断已被忽略时（因为它已包含在相同的 ignore 注释中，或者因为它出现在 ignore-in-file 注释中），分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名为 unused_local_variable 的诊断已被忽略整个文件，因此不需要在特定行上忽略它：

dart
// ignore_for_file: unused_local_variable
void f() {
  // ignore: unused_local_variable
  var x = 0;
}

以下代码会生成此诊断信息，因为名为 unused_local_variable 的诊断在同一行被忽略了两次：

dart
void f() {
  // ignore: unused_local_variable, unused_local_variable
  var x = 0;
}

常规修复

#

删除忽略注释，或者如果忽略注释忽略多个诊断，则删除不必要的诊断名称：

dart
// ignore_for_file: unused_local_variable
void f() {
  var x = 0;
}

duplicate_import

#

重复导入。

说明

#

当找到与文件前面导入的导入相同的导入指令时，分析器会生成此诊断信息。第二个导入不会增加价值，应将其删除。

示例

#

以下代码会生成此诊断信息：

dart
import 'package:meta/meta.dart';
import 'package:meta/meta.dart';

@sealed class C {}

常规修复

#

删除不必要的导入：

dart
import 'package:meta/meta.dart';

@sealed class C {}

duplicate_named_argument

#

已指定命名参数 '{0}' 的参数。

说明

#

当调用具有两个或多个具有相同名称的命名参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为有两个名为 a 的参数：

dart
void f(C c) {
  c.m(a: 0, a: 1);
}

class C {
  void m({int? a, int? b}) {}
}

常规修复

#

如果其中一个参数应该具有不同的名称，则更改名称：

dart
void f(C c) {
  c.m(a: 0, b: 1);
}

class C {
  void m({int? a, int? b}) {}
}

如果其中一个参数错误，则将其删除：

dart
void f(C c) {
  c.m(a: 1);
}

class C {
  void m({int? a, int? b}) {}
}

duplicate_part

#

库已包含具有 URI '{0}' 的部分。

说明

#

当在多个部分指令中引用单个文件时，分析器会生成此诊断信息。

示例

#

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

dart
part of 'test.dart';

以下代码会生成此诊断信息，因为文件 part.dart 被包含多次：

dart
part 'part.dart';
part 'part.dart';

常规修复

#

删除重复的部分指令，只保留第一个：

dart
part 'part.dart';

duplicate_pattern_assignment_variable

#

变量 '{0}' 已在此模式中赋值。

说明

#

当单个模式变量在同一模式赋值中多次赋值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 a 在模式 (a, a) 中被赋值了两次：

dart
int f((int, int) r) {
  int a;
  (a, a) = r;
  return a;
}

常规修复

#

如果您需要捕获所有值，则为要匹配的每个子模式使用唯一的变量：

dart
int f((int, int) r) {
  int a, b;
  (a, b) = r;
  return a + b;
}

如果不需要捕获某些值，则使用通配符模式 _ 以避免必须将值绑定到变量：

dart
int f((int, int) r) {
  int a;
  (_, a) = r;
  return a;
}

duplicate_pattern_field

#

字段 '{0}' 已在此模式中匹配。

说明

#

当记录模式多次匹配同一字段，或者对象模式多次匹配同一 getter 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为记录字段 a 在同一记录模式中被匹配了两次：

dart
void f(({int a, int b}) r) {
  switch (r) {
    case (a: 1, a: 2):
      return;
  }
}

以下代码会生成此诊断信息，因为 getter f 在同一对象模式中被匹配了两次：

dart
void f(Object o) {
  switch (o) {
    case C(f: 1, f: 2):
      return;
  }
}
class C {
  int? f;
}

常规修复

#

如果模式应该匹配重复字段的多个值，则使用逻辑或模式：

dart
void f(({int a, int b}) r) {
  switch (r) {
    case (a: 1, b: _) || (a: 2, b: _):
      break;
  }
}

如果模式应该匹配多个字段，则更改其中一个字段的名称：

dart
void f(({int a, int b}) r) {
  switch (r) {
    case (a: 1, b: 2):
      return;
  }
}

duplicate_rest_element_in_pattern

#

列表或映射模式中最多允许一个 rest 元素。

说明

#

当列表或映射模式中存在多个 rest 模式时，分析器会生成此诊断信息。rest 模式将捕获其他子模式未匹配的任何值，这使得后续的 rest 模式变得不必要，因为没有剩余内容需要捕获。

示例

#

以下代码会生成此诊断信息，因为列表模式中有两个 rest 模式：

dart
void f(List<int> x) {
  if (x case [0, ..., ...]) {}
}

常规修复

#

删除除一个 rest 模式之外的所有 rest 模式：

dart
void f(List<int> x) {
  if (x case [0, ...]) {}
}

duplicate_shown_name

#

重复显示的名称。

说明

#

当名称在 show 子句中多次出现时，分析器会生成此诊断信息。重复名称是不必要的。

示例

#

以下代码会生成此诊断信息，因为名称 min 被显示了多次：

dart
import 'dart:math' show min, min;

var x = min(2, min(0, 1));

常规修复

#

如果在一个或多个地方拼写错误的名称，则更正拼写错误的名称：

dart
import 'dart:math' show max, min;

var x = max(2, min(0, 1));

如果名称没有拼写错误，则从列表中删除不必要的名称：

dart
import 'dart:math' show min;

var x = min(2, min(0, 1));

duplicate_variable_pattern

#

变量 '{0}' 已在此模式中定义。

说明

#

当逻辑与模式的分支声明的变量已在同一模式的早期分支中声明时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 a 在逻辑与模式的两个分支中都被声明：

dart
void f((int, int) r) {
  if (r case (var a, 0) && (0, var a)) {
    print(a);
  }
}

常规修复

#

如果您需要在多个分支中捕获匹配的值，则更改变量的名称，使其唯一：

dart
void f((int, int) r) {
  if (r case (var a, 0) && (0, var b)) {
    print(a + b);
  }
}

如果您只需要在一个分支中捕获匹配的值，则从除一个分支之外的所有分支中删除变量模式：

dart
void f((int, int) r) {
  if (r case (var a, 0) && (0, _)) {
    print(a);
  }
}

empty_map_pattern

#

映射模式必须至少有一个条目。

说明

#

当映射模式为空时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为映射模式为空：

dart
void f(Map<int, String> x) {
  if (x case {}) {}
}

常规修复

#

如果模式应该匹配任何映射，则将其替换为对象模式：

dart
void f(Map<int, String> x) {
  if (x case Map()) {}
}

如果模式应该只匹配空映射，则检查模式中的长度：

dart
void f(Map<int, String> x) {
  if (x case Map(isEmpty: true)) {}
}

empty_record_literal_with_comma

#

没有字段的记录字面量不能有尾随逗号。

说明

#

当没有字段的记录字面量带有尾随逗号时，分析器会生成此诊断信息。空记录字面量不能包含逗号。

示例

#

以下代码会生成此诊断信息，因为空记录字面量带有尾随逗号：

dart
var r = (,);

常规修复

#

如果记录旨在为空，则删除逗号：

dart
var r = ();

如果记录旨在具有一个或多个字段，则添加用于计算这些字段值的表达式：

dart
var r = (3, 4);

empty_record_type_named_fields_list

#

记录类型中的命名字段列表不能为空。

说明

#

当记录类型具有空的命名字段列表时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为记录类型具有空的命名字段列表：

dart
void f((int, int, {}) r) {}

常规修复

#

如果记录旨在具有命名字段，则添加字段的类型和名称：

dart
void f((int, int, {int z}) r) {}

如果记录不打算具有命名字段，则删除花括号：

dart
void f((int, int) r) {}

empty_record_type_with_comma

#

没有字段的记录类型不能有尾随逗号。

说明

#

当没有字段的记录类型带有尾随逗号时，分析器会生成此诊断信息。空记录类型不能包含逗号。

示例

#

以下代码会生成此诊断信息，因为空记录类型带有尾随逗号：

dart
void f((,) r) {}

常规修复

#

如果记录类型旨在为空，则删除逗号：

dart
void f(() r) {}

如果记录类型旨在具有一个或多个字段，则添加这些字段的类型：

dart
void f((int, int) r) {}

empty_struct

#

类 '{0}' 不能为空，因为它是的子类 '{1}'。

说明

#

当 Struct 或 Union 的子类没有任何字段时，分析器会生成此诊断信息。不支持空的 Struct 或 Union 。

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

示例

#

以下代码会生成此诊断信息，因为扩展 Struct 的类 C 没有声明任何字段：

dart
import 'dart:ffi';

final class C extends Struct {}

常规修复

#

如果类旨在为结构体，则声明一个或多个字段：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int32()
  external int x;
}

如果类旨在用作 Pointer 的类型参数，则将其设为 Opaque 的子类：

dart
import 'dart:ffi';

final class C extends Opaque {}

如果类不打算作为结构体，则删除或更改 extends 子句：

dart
class C {}

enum_constant_same_name_as_enclosing

#

枚举值的名称不能与枚举的名称相同。

说明

#

当枚举值与其声明的枚举具有相同的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为枚举值 E 与封闭枚举 E 具有相同的名称：

dart
enum E {
  E
}

常规修复

#

如果枚举的名称正确，则重命名常量：

dart
enum E {
  e
}

如果常量的名称正确，则重命名枚举：

dart
enum F {
  E
}

enum_constant_with_non_const_constructor

#

调用的构造函数不是 'const' 构造函数。

说明

#

当使用未标记为 const 的工厂构造函数或生成式构造函数创建枚举值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为枚举值 e 由工厂构造函数初始化：

dart
enum E {
  e() ;

  factory E() => e;
}

常规修复

#

使用标记为 const 的生成式构造函数：

dart
enum E {
  e._();

  factory E() => e;

  const E._();
}

enum_mixin_with_instance_variable

#

应用于枚举的 mixin 不能有实例变量。

说明

#

当应用于枚举的 mixin 声明一个或多个实例变量时，分析器会生成此诊断信息。这是不允许的，因为枚举值是常量，枚举中的构造函数无法初始化 mixin 的任何字段。

示例

#

以下代码会生成此诊断信息，因为 mixin M 定义了实例字段 x ：

dart
mixin M {
  int x = 0;
}

enum E with M {
  a
}

常规修复

#

如果您需要应用 mixin，则将所有实例字段更改为 getter 和 setter 对，并在必要时在枚举中实现它们：

dart
mixin M {
  int get x => 0;
}

enum E with M {
  a
}

如果您不需要应用 mixin，则将其删除：

dart
enum E {
  a
}

enum_with_abstract_member

#

' {0}' 必须具有方法体，因为 '{1}' 是枚举。

说明

#

当找到没有具体实现的枚举成员时，分析器会生成此诊断信息。枚举不允许包含抽象成员。

示例

#

以下代码会生成此诊断信息，因为 m 是抽象方法，而 E 是枚举：

dart
enum E {
  e;

  void m();
}

常规修复

#

为成员提供实现：

dart
enum E {
  e;

  void m() {}
}

enum_with_name_values

#

名称 'values' 不是枚举的有效名称。

说明

#

当枚举被声明为具有名称 values 时，分析器会生成此诊断信息。这是不允许的，因为枚举有一个名为 values 的隐式静态字段，两者会发生冲突。

示例

#

以下代码会生成此诊断信息，因为有一个名为 values 的枚举声明：

dart
enum values {
  c
}

常规修复

#

将枚举重命名为除 values 之外的其他名称。

equal_elements_in_const_set

#

常量集合字面量中的两个元素不能相等。

说明

#

当常量集合字面量中的两个元素具有相同的值时，分析器会生成此诊断信息。集合只能包含每个值一次，这意味着其中一个值是不必要的。

示例

#

以下代码会生成此诊断信息，因为字符串 'a' 被指定了两次：

dart
const Set<String> set = {'a', 'a'};

常规修复

#

删除重复值之一：

dart
const Set<String> set = {'a'};

请注意，集合字面量会保留其元素的顺序，因此删除哪个元素的选择可能会影响迭代器返回元素的顺序。

equal_elements_in_set

#

集合字面量中的两个元素不应相等。

说明

#

当非常量集合中的元素与同一集合中的先前元素相同时，分析器会生成此诊断信息。如果两个元素相同，则第二个值将被忽略，这使得这两个元素都毫无意义，并且可能表明存在错误。

示例

#

以下代码会生成此诊断信息，因为元素 1 出现了两次：

dart
const a = 1;
const b = 1;
var s = <int>{a, b};

常规修复

#

如果集合中应包含两个元素，则更改其中一个元素：

dart
const a = 1;
const b = 2;
var s = <int>{a, b};

如果只需要其中一个元素，则删除不需要的元素：

dart
const a = 1;
var s = <int>{a};

请注意，集合字面量会保留其元素的顺序，因此删除哪个元素的选择可能会影响迭代器返回元素的顺序。

equal_keys_in_const_map

#

常量映射字面量中的两个键不能相等。

说明

#

当常量映射中的键与同一映射中的先前键相同时，分析器会生成此诊断信息。如果两个键相同，则第二个值将覆盖第一个值，这使得这两对都毫无意义。

示例

#

以下代码会生成此诊断信息，因为键 1 被使用了两次：

dart
const map = <int, String>{1: 'a', 2: 'b', 1: 'c', 4: 'd'};

常规修复

#

如果映射中应包含这两个条目，则将其中一个键更改为不同的键：

dart
const map = <int, String>{1: 'a', 2: 'b', 3: 'c', 4: 'd'};

如果只需要其中一个条目，则删除不需要的条目：

dart
const map = <int, String>{1: 'a', 2: 'b', 4: 'd'};

请注意，映射字面量会保留其条目的顺序，因此删除哪个条目的选择可能会影响迭代器返回键和值的顺序。

equal_keys_in_map

#

映射字面量中的两个键不应相等。

说明

#

当非常量映射中的键与同一映射中的先前键相同时，分析器会生成此诊断信息。如果两个键相同，则第二个值将覆盖第一个值，这使得这两对都毫无意义，并且可能表明存在错误。

示例

#

以下代码会生成此诊断信息，因为键 a 和 b 的值相同：

dart
const a = 1;
const b = 1;
var m = <int, String>{a: 'a', b: 'b'};

常规修复

#

如果映射中应包含这两个条目，则更改其中一个键：

dart
const a = 1;
const b = 2;
var m = <int, String>{a: 'a', b: 'b'};

如果只需要其中一个条目，则删除不需要的条目：

dart
const a = 1;
var m = <int, String>{a: 'a'};

请注意，映射字面量会保留其条目的顺序，因此删除哪个条目的选择可能会影响迭代器返回键和值的顺序。

equal_keys_in_map_pattern

#

映射模式中的两个键不能相等。

说明

#

当映射模式包含多个具有相同名称的键时，分析器会生成此诊断信息。同一个键不能被匹配两次。

示例

#

以下代码会生成此诊断信息，因为键 'a' 出现了两次：

dart
void f(Map<String, int> x) {
  if (x case {'a': 1, 'a': 2}) {}
}

常规修复

#

如果您尝试匹配两个不同的键，则更改模式中的其中一个键：

dart
void f(Map<String, int> x) {
  if (x case {'a': 1, 'b': 2}) {}
}

如果您尝试匹配同一个键，但允许多个模式中的任何一个匹配，则使用逻辑或模式：

dart
void f(Map<String, int> x) {
  if (x case {'a': 1 || 2}) {}
}

expected_one_list_pattern_type_arguments

#

列表模式需要一个类型参数或没有类型参数，但发现 {0}。

说明

#

当列表模式具有多个类型参数时，分析器会生成此诊断信息。列表模式可以具有零个类型参数或一个类型参数，但不能多于一个。

示例

#

以下代码会生成此诊断信息，因为列表模式（ [0] ）有两个类型参数：

dart
void f(Object x) {
  if (x case <int, int>[0]) {}
}

常规修复

#

删除除一个类型参数之外的所有类型参数：

dart
void f(Object x) {
  if (x case <int>[0]) {}
}

expected_one_list_type_arguments

#

列表字面量需要一个类型参数或没有类型参数，但发现 {0}。

说明

#

当列表字面量具有多个类型参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为列表字面量有两个类型参数，而它最多只能有一个：

dart
var l = <int, int>[];

常规修复

#

删除除一个类型参数之外的所有类型参数：

dart
var l = <int>[];

expected_one_set_type_arguments

#

集合字面量需要一个类型参数或没有类型参数，但发现 {0} 个。

说明

#

当集合字面量具有多个类型参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为集合字面量有三个类型参数，而它最多只能有一个：

dart
var s = <int, String, int>{0, 'a', 1};

常规修复

#

删除除一个类型参数之外的所有类型参数：

dart
var s = <int>{0, 1};

expected_two_map_pattern_type_arguments

#

映射模式需要两个类型参数或没有类型参数，但发现 {0}。

说明

#

当映射模式只有一个类型参数或多于两个类型参数时，分析器会生成此诊断信息。映射模式可以具有两个类型参数或零个类型参数，但不能具有其他数量。

示例

#

以下代码会生成此诊断信息，因为映射模式 (<int>{}) 有一个类型参数：

dart
void f(Object x) {
  if (x case <int>{0: _}) {}
}

常规修复

#

添加或删除类型参数，直到有两个或没有：

dart
void f(Object x) {
  if (x case <int, int>{0: _}) {}
}

expected_two_map_type_arguments

#

映射字面量需要两个类型参数或没有类型参数，但发现 {0}。

说明

#

当映射字面量只有一个或多于两个类型参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为映射字面量有三个类型参数，而它可以有两个或零个：

dart
var m = <int, String, int>{};

常规修复

#

删除除两个类型参数之外的所有类型参数：

dart
var m = <int, String>{};

export_internal_library

#

库 '{0}' 是内部库，不能导出。

说明

#

当找到一个其 dart: URI 引用内部库的导出时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 _interceptors 是内部库：

dart
export 'dart:_interceptors';

常规修复

#

删除导出指令。

export_legacy_symbol

#

符号 '{0}' 在旧版库中定义，不能从启用了空安全的库中重新导出。

说明

#

当启用空安全的库导出另一个库，并且导出的库未启用空安全时，分析器会生成此诊断信息。

示例

#

给定一个未启用空安全的库：

dart
// @dart = 2.8
String s;

以下代码会生成此诊断信息，因为它正在导出来自未启用空安全库的符号：

dart
export 'optedOut.dart';

class C {}

常规修复

#

如果您能够这样做，请迁移导出的库，使其不需要选择退出：

dart
String? s;

如果您无法迁移库，则删除导出：

dart
class C {}

如果导出的库（已选择退出的库）本身导出已启用的库，则您的库间接导出已启用库中的符号是有效的。您可以通过向库中的导出指令添加一个隐藏组合器来实现此目的，该组合器隐藏了已选择退出库中声明的所有名称。

export_of_non_library

#

导出的库 '{0}' 不能有 part-of 指令。

说明

#

当导出指令引用的是部分而不是库时，分析器会生成此诊断信息。

示例

#

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

dart
part of lib;

以下代码会生成此诊断信息，因为文件 part.dart 是一个部分，并且只有库可以导出：

dart
library lib;

export 'part.dart';

常规修复

#

删除导出指令，或将 URI 更改为包含该部分的库的 URI。

expression_in_map

#

表达式不能用于映射字面量中。

说明

#

当分析器在看起来像是映射字面量的内容中找到表达式而不是映射条目时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
var map = <String, int>{'a': 0, 'b': 1, 'c'};

常规修复

#

如果表达式旨在计算条目中的键或值，请通过将表达式替换为键或值来解决此问题。例如：

dart
var map = <String, int>{'a': 0, 'b': 1, 'c': 2};

extends_non_class

#

类只能扩展其他类。

说明

#

当 extends 子句包含声明为非类的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 被声明为函数：

dart
void f() {}

class C extends f {}

常规修复

#

如果您希望类扩展除 Object 之外的其他类，则将 extends 子句中的名称替换为该类的名称：

dart
void f() {}

class C extends B {}

class B {}

如果您希望类扩展 Object ，则删除 extends 子句：

dart
void f() {}

class C {}

extension_as_expression

#

扩展 '{0}' 不能用作表达式。

说明

#

当扩展的名称在表达式中使用时（除非在扩展重写中或用于限定对扩展的静态成员的访问），分析器会生成此诊断信息。因为类定义类型，所以类的名称可以用于引用表示类类型的 Type 实例。另一方面，扩展不定义类型，不能用作类型字面量。

示例

#

以下代码会生成此诊断信息，因为 E 是一个扩展：

dart
extension E on int {
  static String m() => '';
}

var x = E;

常规修复

#

将扩展的名称替换为可以引用的名称，例如在扩展中定义的静态成员：

dart
extension E on int {
  static String m() => '';
}

var x = E.m();

extension_conflicting_static_and_instance

#

扩展不能定义静态成员 '{0}' 和具有相同名称的实例成员。

说明

#

当扩展声明同时包含具有相同名称的实例成员和静态成员时，分析器会生成此诊断信息。实例成员和静态成员不能具有相同的名称，因为在扩展体中使用名称的非限定使用时，不清楚正在引用哪个成员。

示例

#

以下代码会生成此诊断信息，因为名称 a 用于两个不同的成员：

dart
extension E on Object {
  int get a => 0;
  static int a() => 0;
}

常规修复

#

重命名或删除其中一个成员：

dart
extension E on Object {
  int get a => 0;
  static int b() => 0;
}

extension_declares_abstract_member

#

扩展不能声明抽象成员。

说明

#

当在扩展中声明抽象声明时，分析器会生成此诊断信息。扩展只能声明具体成员。

示例

#

以下代码会生成此诊断信息，因为方法 a 没有主体：

dart
extension E on String {
  int a() ;
}

常规修复

#

为成员提供实现或将其删除。

extension_declares_constructor

#

扩展不能声明构造函数。

说明

#

当在扩展中找到构造函数声明时，分析器会生成此诊断信息。定义构造函数是无效的，因为扩展不是类，并且不可能创建扩展的实例。

示例

#

以下代码会生成此诊断信息，因为 E 中有一个构造函数声明：

dart
extension E on String {
  E() : super();
}

常规修复

#

删除构造函数或将其替换为静态方法。

extension_declares_instance_field

#

扩展不能声明实例字段

说明

#

当在扩展中找到实例字段声明时，分析器会生成此诊断信息。定义实例字段是无效的，因为扩展只能添加行为，不能添加状态。

示例

#

以下代码会生成此诊断信息，因为 s 是实例字段：

dart
extension E on String {
  String s;
}

常规修复

#

删除该字段，将其设为静态字段，或将其转换为 getter、setter 或方法。

extension_declares_member_of_object

#

扩展不能声明与 'Object' 声明的成员具有相同名称的成员。

说明

#

当扩展声明声明的成员与类 Object 中声明的成员具有相同的名称时，分析器会生成此诊断信息。这样的成员永远不能使用，因为总是先找到 Object 中的成员。

示例

#

以下代码会生成此诊断信息，因为 toString 由 Object 定义：

dart
extension E on String {
  String toString() => this;
}

常规修复

#

删除成员或重命名它，使其名称与 Object 中的成员不冲突：

dart
extension E on String {
  String displayString() => this;
}

extension_override_access_to_static_member

#

扩展重写不能用于从扩展访问静态成员。

说明

#

当扩展重写是静态成员调用的接收者时，分析器会生成此诊断信息。与类中的静态成员类似，应使用扩展的名称访问扩展的静态成员，而不是扩展重写。

示例

#

以下代码会生成此诊断信息，因为 m 是静态的：

dart
extension E on String {
  static void m() {}
}

void f() {
  E(''). m() ;
}

常规修复

#

将扩展重写替换为扩展的名称：

dart
extension E on String {
  static void m() {}
}

void f() {
  E.m();
}

extension_override_argument_not_assignable

#

扩展重写 '{0}' 的参数的类型不能赋值给扩展类型 '{1}'。

说明

#

当扩展重写的参数不能赋值给扩展所扩展的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 3 不是 String ：

dart
extension E on String {
  void method() {}
}

void f() {
  E(3).method();
}

常规修复

#

如果您使用的是正确的扩展，则更新参数使其具有正确的类型：

dart
extension E on String {
  void method() {}
}

void f() {
  E(3.toString()).method();
}

如果存在对参数类型有效的不同扩展，则替换扩展的名称或解包参数，以便找到正确的扩展。

extension_override_without_access

#

扩展重写只能用于访问实例成员。

说明

#

当找到未用于访问扩展成员之一的扩展重写时，分析器会生成此诊断信息。扩展重写语法没有任何运行时语义；它只控制编译时选择哪个成员。

示例

#

以下代码会生成此诊断信息，因为 E(i) 不是表达式：

dart
extension E on int {
  int get a => 0;
}

void f(int i) {
  print(E(i));
}

常规修复

#

如果您想调用扩展的成员之一，则添加调用：

dart
extension E on int {
  int get a => 0;
}

void f(int i) {
  print(E(i).a);
}

如果您不想调用成员，则解包参数：

dart
extension E on int {
  int get a => 0;
}

void f(int i) {
  print(i);
}

extension_override_with_cascade

#

扩展重写没有值，因此不能用作级联表达式的接收者。

说明

#

当扩展重写用作级联表达式的接收者时，分析器会生成此诊断信息。级联表达式 e..m 的值是接收者 e 的值，但扩展重写不是表达式，也没有值。

示例

#

以下代码会生成此诊断信息，因为 E(3) 不是表达式：

dart
extension E on int {
  void m() {}
}
f() {
  E(3) ..m();
}

常规修复

#

使用 . 而不是 .. ：

dart
extension E on int {
  void m() {}
}
f() {
  E(3).m();
}

如果有多个级联访问，则需要为每个访问复制扩展重写。

extension_type_constructor_with_super_formal_parameter

#

扩展类型构造函数不能声明超类形式参数。

说明

#

当扩展类型中的构造函数具有超类参数时，分析器会生成此诊断信息。超类参数无效，因为扩展类型没有超类。

示例

#

以下代码会生成此诊断信息，因为命名构造函数 n 包含超类参数：

dart
extension type E(int i) {
  E.n(this.i, super.foo);
}

常规修复

#

如果您需要该参数，请将超类参数替换为普通参数：

dart
extension type E(int i) {
  E.n(this.i, String foo);
}

如果您不需要该参数，请删除超类参数：

dart
extension type E(int i) {
  E.n(this.i);
}

extension_type_constructor_with_super_invocation

#

扩展类型构造函数不能包含超类初始化器。

说明

#

当扩展类型中的构造函数在其初始化器列表中包含对超类构造函数的调用时，分析器会生成此诊断信息。因为扩展类型没有超类，所以没有构造函数可以调用。

示例

#

以下代码会生成此诊断信息，因为构造函数 E.n 在其初始化器列表中调用了超类构造函数：

dart
extension type E(int i) {
  E.n() : i = 0, super.n();
}

常规修复

#

删除对超类构造函数的调用：

dart
extension type E(int i) {
  E.n() : i = 0;
}

extension_type_declares_instance_field

#

扩展类型不能声明实例字段。

说明

#

当扩展类型声明体中存在字段声明时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展类型 E 声明了一个名为 f 的字段：

dart
extension type E(int i) {
  final int f = 0;
}

常规修复

#

如果您不需要该字段，则将其删除或将其替换为 getter 和/或 setter：

dart
extension type E(int i) {
  int get f => 0;
}

如果您需要该字段，则将扩展类型转换为类：

dart
class E {
  final int i;

  final int f = 0;

  E(this.i);
}

extension_type_declares_member_of_object

#

扩展类型不能声明与 'Object' 声明的成员具有相同名称的成员。

说明

#

当扩展类型声明体包含与 Object 声明的成员之一具有相同名称的成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 Object 已经定义了一个名为 hashCode 的成员：

dart
extension type E(int i) {
  int get hashCode => 0;
}

常规修复

#

如果您需要具有已实现语义的成员，则重命名该成员：

dart
extension type E(int i) {
  int get myHashCode => 0;
}

如果您不需要具有已实现语义的成员，则删除该成员：

dart
extension type E(int i) {}

extension_type_implements_disallowed_type

#

扩展类型不能实现 '{0}'。

说明

#

当扩展类型实现它不允许实现的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展类型不能实现类型 dynamic ：

dart
extension type A(int i) implements dynamic {}

常规修复

#

从 implements 子句中删除不允许的类型：

dart
extension type A(int i) {}

extension_type_implements_itself

#

扩展类型不能实现自身。

说明

#

当扩展类型直接或间接实现自身时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展类型 A 直接实现自身：

dart
extension type A(int i) implements A {}

以下代码会生成此诊断信息，因为扩展类型 A 间接实现自身（通过 B ）：

dart
extension type A(int i) implements B {}

extension type B(int i) implements A {}

常规修复

#

通过从参与循环的至少一个类型的 implements 子句中删除类型来打破循环：

dart
extension type A(int i) implements B {}

extension type B(int i) {}

extension_type_implements_not_supertype

#

' {0}' 不是 '{1}'（表示类型）的超类型。

说明

#

当扩展类型实现的类型不是表示类型的超类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展类型 A 实现 String ，但 String 不是表示类型 int 的超类型：

dart
extension type A(int i) implements String {}

常规修复

#

如果表示类型正确，则删除或替换 implements 子句中的类型：

dart
extension type A(int i) {}

如果表示类型不正确，则将其替换为正确的类型：

dart
extension type A(String s) implements String {}

extension_type_implements_representation_not_supertype

#

' {0}'（'{1}' 的表示类型）不是 '{2}'（'{3}' 的表示类型）的超类型。

说明

#

当扩展类型实现另一个扩展类型，并且已实现扩展类型的表示类型不是实现扩展类型的表示类型的子类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展类型 B 实现 A ，但 A 的表示类型（ num ）不是 B 的表示类型（ String ）的子类型：

dart
extension type A(num i) {}

extension type B(String s) implements A {}

常规修复

#

更改两个扩展类型的表示类型，以便已实现类型的表示类型是实现类型的表示类型的超类型：

dart
extension type A(num i) {}

extension type B(int n) implements A {}

或者从 implements 子句中删除已实现的类型：

dart
extension type A(num i) {}

extension type B(String s) {}

extension_type_inherited_member_conflict

#

扩展类型 '{0}' 从已实现的类型中具有多个不同的名为 '{1}' 的成员。

说明

#

当扩展类型实现两个或多个其他类型，并且至少两个类型声明了具有相同名称的成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展类型 C 同时实现了 A 和 B ，并且两者都声明了一个名为 m 的成员：

dart
class A {
  void m() {}
}

extension type B(A a) {
  void m() {}
}

extension type C(A a) implements A, B {}

常规修复

#

如果扩展类型不需要实现所有列出的类型，则删除引入冲突成员的类型中的所有类型，只保留一个：

dart
class A {
  void m() {}
}

extension type B(A a) {
  void m() {}
}

extension type C(A a) implements A {}

如果扩展类型需要实现所有列出的类型，但您可以重命名这些类型中的成员，则为冲突的成员提供唯一的名称：

dart
class A {
  void m() {}
}

extension type B(A a) {
  void n() {}
}

extension type C(A a) implements A, B {}

extension_type_representation_depends_on_itself

#

扩展类型表示不能依赖于自身。

说明

#

当扩展类型的表示类型直接或间接依赖于扩展类型本身时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展类型 A 的表示类型直接依赖于 A ：

dart
extension type A(A a) {}

以下两个代码示例会生成此诊断信息，因为扩展类型 A 的表示类型通过扩展类型 B 间接依赖于 A ：

dart
extension type A(B b) {}

extension type B(A a) {}
dart
extension type A(List<B> b) {}

extension type B(List<A> a) {}

常规修复

#

通过为循环中的至少一个类型选择不同的表示类型来删除依赖关系：

dart
extension type A(String s) {}

extension_type_representation_type_bottom

#

表示类型不能是底部类型。

说明

#

当扩展类型的表示类型是底部类型 底部类型 Never 时，分析器会生成此诊断信息。类型 Never 不能是扩展类型的表示类型，因为没有可以扩展的值。

示例

#

以下代码会生成此诊断信息，因为扩展类型 E 的表示类型是 Never ：

dart
extension type E(Never n) {}

常规修复

#

将扩展类型替换为不同的类型：

dart
extension type E(String s) {}

extension_type_with_abstract_member

#

' {0}' 必须具有方法体，因为 '{1}' 是扩展类型。

说明

#

当扩展类型声明抽象成员时，分析器会生成此诊断信息。由于扩展类型成员引用是静态解析的，因此扩展类型中的抽象成员永远无法执行。

示例

#

以下代码会生成此诊断信息，因为扩展类型 E 中的方法 m 是抽象的：

dart
extension type E(String s) {
  void m();
}

常规修复

#

如果成员旨在可执行，则提供成员的实现：

dart
extension type E(String s) {
  void m() {}
}

如果成员不旨在可执行，则将其删除：

dart
extension type E(String s) {}

external_with_initializer

#

外部字段不能有初始化器。

外部变量不能有初始化器。

说明

#

当用关键字 external 标记的字段或变量具有初始化器，或者在构造函数中初始化外部字段时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为外部字段 x 在初始化器中被赋值：

dart
class C {
  external int x;
  C() : x = 0;
}

以下代码会生成此诊断信息，因为外部字段 x 有一个初始化器：

dart
class C {
  external final int x = 0;
}

以下代码会生成此诊断信息，因为外部顶级变量 x 有一个初始化器：

dart
external final int x = 0;

常规修复

#

删除初始化器：

dart
class C {
  external final int x;
}

extra_annotation_on_struct_field

#

结构体类中的字段必须恰好有一个注解来指示本机类型。

说明

#

当 Struct 的子类中的字段具有多个描述字段的本机类型的注解时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 x 有两个注解来描述字段的本机类型：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int32()
  @Int16()
  external int x;
}

常规修复

#

删除除一个注解之外的所有注解：

dart
import 'dart:ffi';
final class C extends Struct {
  @Int32()
  external int x;
}

extra_positional_arguments

#

位置参数过多：预期 {0} 个，但发现 {1} 个。

说明

#

当方法或函数调用具有的位置参数多于方法或函数允许的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 定义了 2 个参数，但使用 3 个参数调用：

dart
void f(int a, int b) {}
void g() {
  f(1, 2, 3);
}

常规修复

#

删除与参数不对应的参数：

dart
void f(int a, int b) {}
void g() {
  f(1, 2);
}

extra_positional_arguments_could_be_named

#

位置参数过多：预期 {0} 个，但发现 {1} 个。

说明

#

当方法或函数调用的位置参数多于方法或函数允许的参数，但方法或函数定义了命名参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 定义了 2 个位置参数，但有一个命名参数可用于第三个参数：

dart
void f(int a, int b, {int? c}) {}
void g() {
  f(1, 2, 3);
}

常规修复

#

如果某些参数应该是命名参数的值，则在参数前添加名称：

dart
void f(int a, int b, {int? c}) {}
void g() {
  f(1, 2, c: 3);
}

否则，删除与位置参数不对应的参数：

dart
void f(int a, int b, {int? c}) {}
void g() {
  f(1, 2);
}

extra_size_annotation_carray

#

'Array' 必须恰好有一个 'Array' 注解。

说明

#

当 Struct 的子类中的字段具有多个注解来描述本机数组的大小时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 有两个注解指定了本机数组的大小：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(4)
  @Array(8)
  external Array<Uint8> a0;
}

常规修复

#

删除除一个注解之外的所有注解：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

ffi_native_invalid_duplicate_default_asset

#

库上最多只能有一个 @DefaultAsset 注解。

说明

#

当库指令具有与其关联的多个 DefaultAsset 注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为库指令与其关联了两个 DefaultAsset 注解：

dart
@DefaultAsset('a')
@ DefaultAsset('b')
library;

import 'dart:ffi';

常规修复

#

删除除一个 DefaultAsset 注解之外的所有注解：

dart
@DefaultAsset('a')
library;

import 'dart:ffi';

ffi_native_invalid_multiple_annotations

#

本机函数和字段必须恰好有一个 @Native 注解。

说明

#

当单个声明上存在多个 Native 注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 与其关联了两个 Native 注解：

dart
import 'dart:ffi';

@Native<Int32 Function(Int32)>()
@Native<Int32 Function(Int32)>(isLeaf: true)
external int f(int v);

常规修复

#

删除除一个注解之外的所有注解：

dart
import 'dart:ffi';

@Native<Int32 Function(Int32)>(isLeaf: true)
external int f(int v);

ffi_native_must_be_external

#

本机函数必须声明为 external。

说明

#

当用 @Native 注释的函数未标记为 external 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 free 被注释为 @Native ，但该函数未标记为 external ：

dart
import 'dart:ffi';

@Native<Void Function(Pointer<Void>)>()
void free(Pointer<Void> ptr) {}

常规修复

#

如果该函数是本机函数，则在返回类型之前添加修饰符 external ：

dart
import 'dart:ffi';

@Native<Void Function(Pointer<Void>)>()
external void free(Pointer<Void> ptr);

ffi_native_unexpected_number_of_parameters

#

Native 注解参数数量意外。预期 {0} 个，但有 {1} 个。

说明

#

当用作 @Native 注解的类型参数的函数类型中的参数数量与被注释的函数中的参数数量不匹配时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为用作 @Native 注解的类型参数的函数类型（ Void Function(Double) ）有一个参数，而被注释的函数的类型（ void f(double, double) ）有两个参数：

dart
import 'dart:ffi';

@Native<Void Function(Double)>(symbol: 'f')
external void f(double x, double y) ;

常规修复

#

如果被注释的函数正确，则更新 @Native 注解中的函数类型以匹配：

dart
import 'dart:ffi';

@Native<Void Function(Double, Double)>(symbol: 'f')
external void f(double x, double y);

如果 @Native 注解中的函数类型正确，则更新被注释的函数以匹配：

dart
import 'dart:ffi';

@Native<Void Function(Double)>(symbol: 'f')
external void f(double x);

ffi_native_unexpected_number_of_parameters_with_receiver

#

Native 注解参数数量意外。预期 {0} 个，但有 {1} 个。Native 实例方法注解必须将接收者作为第一个参数。

说明

#

当在本地方法的 @Native 注解上使用的类型参数不包含方法接收者的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 @Native 注解上的类型参数（ Void Function(Double) ）不包含方法接收者的类型：

dart
import 'dart:ffi';

class C {
  @Native<Void Function(Double)>()
  external void f(double x) ;
}

常规修复

#

添加一个类型与声明本地方法的类相同的初始参数：

dart
import 'dart:ffi';

class C {
  @Native<Void Function(C, Double)>()
  external void f(double x);
}

field_initialized_by_multiple_initializers

#

字段 '{0}' 不能在同一个构造函数中初始化两次。

说明

#

当构造函数的初始化器列表多次初始化字段时，分析器会生成此诊断信息。允许这两个初始化器都没有意义，因为只保留最后一个值。

示例

#

以下代码会生成此诊断信息，因为字段 f 被初始化了两次：

dart
class C {
  int f;

  C() : f = 0, f = 1;
}

常规修复

#

删除其中一个初始化器：

dart
class C {
  int f;

  C() : f = 0;
}

field_initialized_in_initializer_and_declaration

#

如果字段是 final 并且在其声明中已初始化，则不能在构造函数中初始化字段。

说明

#

当最终字段在字段的声明中和构造函数的初始化器中都被初始化时，分析器会生成此诊断信息。最终字段只能赋值一次，因此不能在这两个地方都初始化。

示例

#

以下代码会生成此诊断信息，因为 f 是：

dart
class C {
  final int f = 0;
  C() : f = 1;
}

常规修复

#

如果初始化不依赖于传递给构造函数的任何值，并且所有构造函数都需要将字段初始化为相同的值，则从构造函数中删除初始化器：

dart
class C {
  final int f = 0;
  C();
}

如果初始化取决于传递给构造函数的值，或者不同的构造函数需要以不同的方式初始化字段，则删除字段声明中的初始化器：

dart
class C {
  final int f;
  C() : f = 1;
}

field_initialized_in_parameter_and_initializer

#

不能在参数列表和初始化器中同时初始化字段。

说明

#

当字段在参数列表和构造函数的初始化器列表中都被初始化时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 f 通过初始化形式参数和初始化器列表都被初始化：

dart
class C {
  int f;

  C(this.f) : f = 0;
}

常规修复

#

如果字段应由参数初始化，则删除初始化器列表中的初始化：

dart
class C {
  int f;

  C(this.f);
}

如果字段应在初始化器列表中初始化并且不需要参数，则删除参数：

dart
class C {
  int f;

  C() : f = 0;
}

如果字段应在初始化器列表中初始化并且需要参数，则将其设为普通参数：

dart
class C {
  int f;

  C(int g) : f = g * 2;
}

field_initializer_factory_constructor

#

初始化形式参数不能用于工厂构造函数中。

说明

#

当工厂构造函数具有初始化形式参数时，分析器会生成此诊断信息。工厂构造函数不能为字段赋值，因为没有创建实例；因此，没有要赋值的字段。

示例

#

以下代码会生成此诊断信息，因为工厂构造函数使用初始化形式参数：

dart
class C {
  int? f;

  factory C(this.f) => throw 0;
}

常规修复

#

将初始化形式参数替换为普通参数：

dart
class C {
  int? f;

  factory C(int f) => throw 0;
}

field_initializer_in_struct

#

'Struct' 和 'Union' 的子类中的构造函数不能有字段初始化器。

说明

#

当 Struct 或 Union 的子类中的构造函数具有一个或多个字段初始化器时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为类 C 的构造函数具有字段 f 的初始化器：

dart
// @dart = 2.9
import 'dart:ffi';

final class C extends Struct {
  @Int32()
  int f;

  C() : f = 0;
}

常规修复

#

删除字段初始化器：

dart
// @dart = 2.9
import 'dart:ffi';

final class C extends Struct {
  @Int32()
  int f;

  C();
}

field_initializer_not_assignable

#

初始化器类型 '{0}' 无法赋值给 const 构造函数中字段类型 '{1}'。

初始化器类型 '{0}' 无法赋值给字段类型 '{1}'。

说明

#

当构造函数的初始化器列表将字段初始化为不可赋值的值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 0 的类型为 int ，而 int 无法赋值给类型为 String 的字段：

dart
class C {
  String s;

  C() : s = 0;
}

常规修复

#

如果字段的类型正确，则更改为其赋值的值，以便该值具有有效的类型：

dart
class C {
  String s;

  C() : s = '0';
}

如果值的类型正确，则更改字段的类型以允许赋值：

dart
class C {
  int s;

  C() : s = 0;
}

field_initializer_outside_constructor

#

字段形式参数只能在构造函数中使用。

初始化形式参数只能在构造函数中使用。

说明

#

示例

#

以下代码会生成此诊断信息，因为初始化形式参数 this.x 用于方法 m 中：

dart
class A {
  int x = 0;

  m([this.x = 0]) {}
}

常规修复

#

将初始化形式参数替换为普通参数，并在方法体中赋值：

dart
class A {
  int x = 0;

  m([int x = 0]) {
    this.x = x;
  }
}

field_initializer_redirecting_constructor

#

重定向构造函数不能有字段初始化器。

说明

#

当重定向构造函数初始化对象中的字段时，分析器会生成此诊断信息。这是不允许的，因为在应该初始化字段的点，尚未创建具有该字段的实例。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.zero 重定向到构造函数 C ，并且有一个初始化形式参数初始化字段 f ：

dart
class C {
  int f;

  C(this.f);

  C.zero(this.f) : this(f);
}

以下代码会生成此诊断信息，因为构造函数 C.zero 重定向到构造函数 C ，并且有一个初始化器初始化字段 f ：

dart
class C {
  int f;

  C(this.f);

  C.zero() : f = 0, this(1);
}

常规修复

#

如果初始化由初始化形式参数完成，则使用普通参数：

dart
class C {
  int f;

  C(this.f);

  C.zero(int f) : this(f);
}

如果初始化在初始化器中完成，则删除初始化器：

dart
class C {
  int f;

  C(this.f);

  C.zero() : this(0);
}

field_initializing_formal_not_assignable

#

参数类型 '{0}' 与字段类型 '{1}' 不兼容。

说明

#

当初始化形式参数的类型无法赋值给正在初始化的字段的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为初始化形式参数的类型为 String ，但字段的类型为 int 。参数必须具有类型为字段类型的子类型的类型。

dart
class C {
  int f;

  C(String this.f);
}

常规修复

#

如果字段的类型不正确，则更改字段的类型以匹配参数的类型，并考虑从参数中删除类型：

dart
class C {
  String f;

  C(this.f);
}

如果参数的类型不正确，则删除参数的类型：

dart
class C {
  int f;

  C(this.f);
}

如果字段和参数的类型都正确，则使用初始化器而不是初始化形式参数将参数值转换为正确类型的值：

dart
class C {
  int f;

  C(String s) : f = int.parse(s);
}

field_in_struct_with_initializer

#

'Struct' 和 'Union' 的子类中的字段不能有初始化器。

说明

#

当 Struct 的子类中的字段具有初始化器时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 p 有一个初始化器：

dart
// @dart = 2.9
import 'dart:ffi';

final class C extends Struct {
  Pointer p = nullptr;
}

常规修复

#

删除初始化器：

dart
// @dart = 2.9
import 'dart:ffi';

final class C extends Struct {
  Pointer p;
}

field_must_be_external_in_struct

#

'Struct' 和 'Union' 子类的字段必须标记为 external。

说明

#

当 Struct 或 Union 的子类中的字段未标记为 external 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a 未标记为 external ：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int16()
  int a;
}

常规修复

#

添加必需的 external 修饰符：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int16()
  external int a;
}

final_initialized_in_declaration_and_constructor

#

' {0}' 是 final 的，并且在其声明时被赋予了一个值，因此不能将其设置为新值。

说明

#

当最终字段被初始化两次时，分析器会生成此诊断信息：一次在其声明时，一次由构造函数的参数初始化。

示例

#

以下代码会生成此诊断信息，因为字段 f 被初始化了两次：

dart
class C {
  final int f = 0;

  C(this.f);
}

常规修复

#

如果字段对所有实例都应该具有相同的值，则删除参数列表中的初始化：

dart
class C {
  final int f = 0;

  C();
}

如果字段在不同实例中可以具有不同的值，则删除声明中的初始化：

dart
class C {
  final int f;

  C(this.f);
}

final_not_initialized

#

final 变量 '{0}' 必须初始化。

说明

#

当 final 字段或变量未初始化时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 没有初始化器：

dart
final x;

常规修复

#

对于变量和静态字段，您可以添加初始化器：

dart
final x = 0;

对于实例字段，您可以添加初始化器（如上例所示），也可以在每个构造函数中初始化该字段。您可以使用初始化形式参数来初始化该字段：

dart
class C {
  final int x;
  C(this.x);
}

您也可以在构造函数的初始化器中初始化该字段：

dart
class C {
  final int x;
  C(int y) : x = y * 2;
}

final_not_initialized_constructor

#

所有 final 变量都必须初始化，但 '{0}' 和 '{1}' 没有初始化。

所有 final 变量都必须初始化，但 '{0}' 没有初始化。

所有 final 变量都必须初始化，但 '{0}'、'{1}' 和其他 {2} 个变量没有初始化。

说明

#

当类定义了一个或多个没有初始化器的 final 实例字段，并且至少有一个构造函数没有初始化这些字段时，分析器会生成此诊断信息。在创建实例时，所有 final 实例字段都必须初始化，方法是使用字段的初始化器或构造函数。

示例

#

以下代码会生成此诊断信息：

dart
class C {
  final String value;

  C() ;
}

常规修复

#

如果应该直接将值传递给构造函数，则使用初始化形式参数来初始化字段 value ：

dart
class C {
  final String value;

  C(this.value);
}

如果应该从调用者提供的值间接计算值，则添加参数并包含初始化器：

dart
class C {
  final String value;

  C(Object o) : value = o.toString();
}

如果字段的值不依赖于可以传递给构造函数的值，则在字段声明中添加字段的初始化器：

dart
class C {
  final String value = '';

  C();
}

如果字段的值不依赖于可以传递给构造函数的值，但不同的构造函数需要将其初始化为不同的值，则在初始化器列表中添加字段的初始化器：

dart
class C {
  final String value;

  C() : value = '';

  C.named() : value = 'c';
}

但是，如果所有实例的值都相同，则考虑使用静态字段而不是实例字段：

dart
class C {
  static const String value = '';

  C();
}

flutter_field_not_map

#

'flutter' 字段的值应为映射。

说明

#

当 flutter 键的值不是映射时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级 flutter 键的值是字符串：

yaml
name: example
flutter: true

常规修复

#

如果您需要指定 Flutter 特定的选项，则将值更改为映射：

yaml
name: example
flutter:
  uses-material-design: true

如果您不需要指定 Flutter 特定的选项，则删除 flutter 键：

yaml
name: example

for_in_of_invalid_element_type

#

'for' 循环中使用的类型 '{0}' 必须实现 '{1}'，并具有可以赋值给 '{2}' 的类型参数。

说明

#

当 for-in 循环中的 Iterable 或 Stream 的元素类型无法赋值给循环变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 <String>[] 的元素类型为 String ，而 String 无法赋值给 e 的类型（ int ）：

dart
void f() {
  for (int e in <String>[]) {
    print(e);
  }
}

常规修复

#

如果循环变量的类型正确，则更新可迭代对象的类型：

dart
void f() {
  for (int e in <int>[]) {
    print(e);
  }
}

如果可迭代对象的类型正确，则更新循环变量的类型：

dart
void f() {
  for (String e in <String>[]) {
    print(e);
  }
}

for_in_of_invalid_type

#

'for' 循环中使用的类型 '{0}' 必须实现 '{1}'。

说明

#

当 for-in 循环中 in 后的表达式的类型不是 Iterable 的子类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 是 Map ，而 Map 不是 Iterable 的子类：

dart
void f(Map<String, String> m) {
  for (String s in m) {
    print(s);
  }
}

常规修复

#

将表达式替换为产生可迭代值的值：

dart
void f(Map<String, String> m) {
  for (String s in m.values) {
    print(s);
  }
}

for_in_with_const_variable

#

for-in 循环变量不能是 'const'。

说明

#

当 for-in 循环中声明的循环变量声明为 const 时，分析器会生成此诊断信息。该变量不能是 const ，因为该值不能在编译时计算。

示例

#

以下代码会生成此诊断信息，因为循环变量 x 被声明为 const ：

dart
void f() {
  for (const x in [0, 1, 2]) {
    print(x);
  }
}

常规修复

#

如果有类型注解，则从声明中删除 const 修饰符。

如果没有类型，则将 const 修饰符替换为 final 、 var 或类型注解：

dart
void f() {
  for (final x in [0, 1, 2]) {
    print(x);
  }
}

generic_method_type_instantiation_on_dynamic

#

对类型为 'dynamic' 的接收者的方法 tear-off 不能具有类型参数。

说明

#

当从类型为 dynamic 的接收者中分离实例方法时，分析器会生成此诊断信息，并且分离包括类型参数。因为分析器无法知道该方法有多少个类型参数，或者它是否具有任何类型参数，所以它无法验证类型参数是否正确。因此，不允许使用类型参数。

示例

#

以下代码会生成此诊断信息，因为 p 的类型为 dynamic ，并且 m 的分离具有类型参数：

dart
void f(dynamic list) {
  list.fold<int>;
}

常规修复

#

如果您可以使用比 dynamic 更具体的类型，则更改接收者的类型：

dart
void f(List<Object> list) {
  list.fold<int>;
}

如果您无法使用更具体的类型，则删除类型参数：

dart
void f(dynamic list) {
  list.cast;
}

generic_struct_subclass

#

扩展结构体不能是泛型的。

说明

#

当初始化形式参数用于构造函数以外的任何内容的参数列表中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为初始化形式参数 this.x 用于方法 m 中：

dart
class A {
  int x = 0;

  m([this.x = 0]) {}
}

常规修复

#

将初始化形式参数替换为普通参数，并在方法体中赋值：

dart
class A {
  int x = 0;

  m([int x = 0]) {
    this.x = x;
  }
}

field_initializer_redirecting_constructor

#

重定向构造函数不能有字段初始化器。

说明

#

当重定向构造函数初始化对象中的字段时，分析器会生成此诊断信息。这是不允许的，因为在应该初始化字段的点，尚未创建具有该字段的实例。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.zero 重定向到构造函数 C ，并且有一个初始化形式参数初始化字段 f ：

dart
class C {
  int f;

  C(this.f);

  C.zero(this.f) : this(f);
}

以下代码会生成此诊断信息，因为构造函数 C.zero 重定向到构造函数 C ，并且有一个初始化器初始化字段 f ：

dart
class C {
  int f;

  C(this.f);

  C.zero() : f = 0, this(1);
}

常规修复

#

如果初始化由初始化形式参数完成，则使用普通参数：

dart
class C {
  int f;

  C(this.f);

  C.zero(int f) : this(f);
}

如果初始化在初始化器中完成，则删除初始化器：

dart
class C {
  int f;

  C(this.f);

  C.zero() : this(0);
}

field_initializing_formal_not_assignable

#

参数类型 '{0}' 与字段类型 '{1}' 不兼容。

说明

#

当初始化形式参数的类型无法赋值给正在初始化的字段的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为初始化形式参数的类型为 String ，但字段的类型为 int 。参数必须具有类型为字段类型的子类型的类型。

dart
class C {
  int f;

  C(String this.f);
}

常规修复

#

如果字段的类型不正确，则更改字段的类型以匹配参数的类型，并考虑从参数中删除类型：

dart
class C {
  String f;

  C(this.f);
}

如果参数的类型不正确，则删除参数的类型：

dart
class C {
  int f;

  C(this.f);
}

如果字段和参数的类型都正确，则使用初始化器而不是初始化形式参数将参数值转换为正确类型的值：

dart
class C {
  int f;

  C(String s) : f = int.parse(s);
}

field_in_struct_with_initializer

#

'Struct' 和 'Union' 的子类中的字段不能有初始化器。

说明

#

当 Struct 的子类中的字段具有初始化器时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 p 有一个初始化器：

dart
// @dart = 2.9
import 'dart:ffi';

final class C extends Struct {
  Pointer p = nullptr;
}

常规修复

#

删除初始化器：

dart
// @dart = 2.9
import 'dart:ffi';

final class C extends Struct {
  Pointer p;
}

field_must_be_external_in_struct

#

'Struct' 和 'Union' 子类的字段必须标记为 external。

说明

#

当 Struct 或 Union 的子类中的字段未标记为 external 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a 未标记为 external ：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int16()
  int a;
}

常规修复

#

添加必需的 external 修饰符：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int16()
  external int a;
}

final_initialized_in_declaration_and_constructor

#

' {0}' 是 final 的，并且在其声明时被赋予了一个值，因此不能将其设置为新值。

说明

#

当 final 字段被初始化两次时，分析器会生成此诊断信息：一次在其声明时，一次由构造函数的参数初始化。

示例

#

以下代码会生成此诊断信息，因为字段 f 被初始化了两次：

dart
class C {
  final int f = 0;

  C(this.f);
}

常规修复

#

如果字段对所有实例都应该具有相同的值，则删除参数列表中的初始化：

dart
class C {
  final int f = 0;

  C();
}

如果字段在不同实例中可以具有不同的值，则删除声明中的初始化：

dart
class C {
  final int f;

  C(this.f);
}

final_not_initialized

#

final 变量 '{0}' 必须初始化。

说明

#

当 final 字段或变量未初始化时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 没有初始化器：

dart
final x;

常规修复

#

对于变量和静态字段，您可以添加初始化器：

dart
final x = 0;

对于实例字段，您可以添加初始化器（如上例所示），也可以在每个构造函数中初始化该字段。您可以使用初始化形式参数来初始化该字段：

dart
class C {
  final int x;
  C(this.x);
}

您也可以在构造函数的初始化器中初始化该字段：

dart
class C {
  final int x;
  C(int y) : x = y * 2;
}

final_not_initialized_constructor

#

所有 final 变量都必须初始化，但 '{0}' 和 '{1}' 没有初始化。

所有 final 变量都必须初始化，但 '{0}' 没有初始化。

所有 final 变量都必须初始化，但 '{0}'、'{1}' 和其他 {2} 个变量没有初始化。

说明

#

当类定义了一个或多个没有初始化器的 final 实例字段，并且至少有一个构造函数没有初始化这些字段时，分析器会生成此诊断信息。在创建实例时，所有 final 实例字段都必须初始化，方法是使用字段的初始化器或构造函数。

示例

#

以下代码会生成此诊断信息：

dart
class C {
  final String value;

  C() ;
}

常规修复

#

如果应该直接将值传递给构造函数，则使用初始化形式参数来初始化字段 value ：

dart
class C {
  final String value;

  C(this.value);
}

如果应该从调用者提供的值间接计算值，则添加参数并包含初始化器：

dart
class C {
  final String value;

  C(Object o) : value = o.toString();
}

如果字段的值不依赖于可以传递给构造函数的值，则在字段声明中添加字段的初始化器：

dart
class C {
  final String value = '';

  C();
}

如果字段的值不依赖于可以传递给构造函数的值，但不同的构造函数需要将其初始化为不同的值，则在初始化器列表中添加字段的初始化器：

dart
class C {
  final String value;

  C() : value = '';

  C.named() : value = 'c';
}

但是，如果所有实例的值都相同，则考虑使用静态字段而不是实例字段：

dart
class C {
  static const String value = '';

  C();
}

flutter_field_not_map

#

'flutter' 字段的值应为映射。

说明

#

当 flutter 键的值不是映射时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级 flutter 键的值是字符串：

yaml
name: example
flutter: true

常规修复

#

如果您需要指定 Flutter 特定的选项，则将值更改为映射：

yaml
name: example
flutter:
  uses-material-design: true

如果您不需要指定 Flutter 特定的选项，则删除 flutter 键：

yaml
name: example

for_in_of_invalid_element_type

#

'for' 循环中使用的类型 '{0}' 必须实现 '{1}'，并具有可以赋值给 '{2}' 的类型参数。

说明

#

当 for-in 循环中的 Iterable 或 Stream 的元素类型无法赋值给循环变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 <String>[] 的元素类型为 String ，而 String 无法赋值给 e 的类型（ int ）：

dart
void f() {
  for (int e in <String>[]) {
    print(e);
  }
}

常规修复

#

如果循环变量的类型正确，则更新可迭代对象的类型：

dart
void f() {
  for (int e in <int>[]) {
    print(e);
  }
}

如果可迭代对象的类型正确，则更新循环变量的类型：

dart
void f() {
  for (String e in <String>[]) {
    print(e);
  }
}

for_in_of_invalid_type

#

'for' 循环中使用的类型 '{0}' 必须实现 '{1}'。

说明

#

当 for-in 循环中 in 后的表达式的类型不是 Iterable 的子类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 是 Map ，而 Map 不是 Iterable 的子类：

dart
void f(Map<String, String> m) {
  for (String s in m) {
    print(s);
  }
}

常规修复

#

将表达式替换为产生可迭代值的值：

dart
void f(Map<String, String> m) {
  for (String s in m.values) {
    print(s);
  }
}

for_in_with_const_variable

#

for-in 循环变量不能是 'const'。

说明

#

当 for-in 循环中声明的循环变量声明为 const 时，分析器会生成此诊断信息。该变量不能是 const ，因为该值不能在编译时计算。

示例

#

以下代码会生成此诊断信息，因为循环变量 x 被声明为 const ：

dart
void f() {
  for (const x in [0, 1, 2]) {
    print(x);
  }
}

常规修复

#

如果有类型注解，则从声明中删除 const 修饰符。

如果没有类型，则将 const 修饰符替换为 final 、 var 或类型注解：

dart
void f() {
  for (final x in [0, 1, 2]) {
    print(x);
  }
}

generic_method_type_instantiation_on_dynamic

#

对类型为 'dynamic' 的接收者的方法 tear-off 不能具有类型参数。

说明

#

当从类型为 dynamic 的接收者中分离实例方法时，分析器会生成此诊断信息，并且分离包括类型参数。因为分析器无法知道该方法有多少个类型参数，或者它是否具有任何类型参数，所以它无法验证类型参数是否正确。因此，不允许使用类型参数。

示例

#

以下代码会生成此诊断信息，因为 p 的类型为 dynamic ，并且 m 的分离具有类型参数：

dart
void f(dynamic list) {
  list.fold<int>;
}

常规修复

#

如果您可以使用比 dynamic 更具体的类型，则更改接收者的类型：

dart
void f(List<Object> list) {
  list.fold<int>;
}

如果无法使用更具体的类型，则删除类型参数：

dart
void f(dynamic list) {
  list.cast;
}

generic_struct_subclass

#

扩展结构体不能是泛型的。

说明

#

当 Struct 或 Union 的子类具有类型参数时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为类 S 定义了类型参数 T ：

dart
import 'dart:ffi';

final class S<T> extends Struct {
  external Pointer notEmpty;
}

常规修复

#

从类中删除类型参数：

dart
import 'dart:ffi';

final class S extends Struct {
  external Pointer notEmpty;
}

getter_not_subtype_setter_types

#

getter '{0}' 的返回类型是 '{1}'，它不是其 setter '{3}' 的类型 '{2}' 的子类型。

说明

#

当 getter 的返回类型不是与具有相同名称的 setter 的参数的类型的子类型时，分析器会生成此诊断信息。

无论 getter 和 setter 是否在同一个类中，或者它们中的一个是否是另一个的超类，子类型关系都是一项要求。

示例

#

以下代码会生成此诊断信息，因为 getter x 的返回类型是 num ，setter x 的参数类型是 int ，而 num 不是 int 的子类型：

dart
class C {
  num get x => 0;

  set x(int y) {}
}

常规修复

#

如果 getter 的类型正确，则更改 setter 的类型：

dart
class C {
  num get x => 0;

  set x(num y) {}
}

如果 setter 的类型正确，则更改 getter 的类型：

dart
class C {
  int get x => 0;

  set x(int y) {}
}

illegal_async_generator_return_type

#

标记为 'async*' 的函数必须具有返回类型，该类型对于某些类型 'T' 来说是 'Stream' 的超类型。

说明

#

当函数体具有 async* 修饰符，但函数的返回类型既不是 Stream 也不是 Stream 的超类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 的体具有 'async*' 修饰符，但返回类型 int 不是 Stream 的超类型：

dart
int f() async* {}

常规修复

#

如果函数应该是异步的，则将返回类型更改为 Stream 或 Stream 的超类型：

dart
Stream<int> f() async* {}

如果函数应该是同步的，则删除 async* 修饰符：

dart
int f() => 0;

illegal_async_return_type

#

标记为 'async' 的函数必须具有返回类型，该类型是 'Future' 的超类型。

说明

#

当函数体具有 async 修饰符，但函数的返回类型无法赋值给 Future 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 的体具有 async 修饰符，但返回类型无法赋值给 Future ：

dart
int f() async {
  return 0;
}

常规修复

#

如果函数应该是异步的，则将返回类型更改为可赋值给 Future ：

dart
Future<int> f() async {
  return 0;
}

如果函数应该是同步的，则删除 async 修饰符：

dart
int f() => 0;

illegal_concrete_enum_member

#

在实现 'Enum' 的类中，不能声明名为 '{0}' 的具体实例成员。

在实现 'Enum' 的类中，不能从 '{1}' 继承名为 '{0}' 的具体实例成员。

说明

#

当枚举声明、实现 Enum 的类或具有 Enum 超类约束的 mixin 声明或继承名为 index 、 hashCode 或 == 的具体实例成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为枚举 E 声明了一个名为 index 的实例 getter：

dart
enum E {
  v;

  int get index => 0;
}

以下代码会生成此诊断信息，因为实现 Enum 的类 C 声明了一个名为 hashCode 的实例字段：

dart
abstract class C implements Enum {
  int hashCode = 0;
}

以下代码会生成此诊断信息，因为类 C 通过类 A 间接实现 Enum ，并声明了一个名为 hashCode 的实例 getter：

dart
abstract class A implements Enum {}

abstract class C implements A {
  int get hashCode => 0;
}

以下代码会生成此诊断信息，因为 mixin M 在 on 子句中具有 Enum ，并声明了一个名为 == 的显式运算符：

dart
mixin M on Enum {
  bool operator ==(Object other) => false;
}

常规修复

#

重命名冲突的成员：

dart
enum E {
  v;

  int get getIndex => 0;
}

illegal_enum_values

#

在实现 'Enum' 的类中，不能声明名为 'values' 的实例成员。

在实现 'Enum' 的类中，不能从 '{0}' 继承名为 'values' 的实例成员。

说明

#

当实现 Enum 的类或具有 Enum 超类约束的 mixin 具有名为 values 的实例成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为实现 Enum 的类 C 声明了一个名为 values 的实例字段：

dart
abstract class C implements Enum {
  int get values => 0;
}

以下代码会生成此诊断信息，因为实现 Enum 的类 B 从 A 继承了一个名为 values 的实例方法：

dart
abstract class A {
  int values() => 0;
}

abstract class B extends A implements Enum {}

常规修复

#

更改冲突成员的名称：

dart
abstract class C implements Enum {
  int get value => 0;
}

illegal_sync_generator_return_type

#

标记为 'sync*' 的函数必须具有返回类型，该类型对于某些类型 'T' 来说是 'Iterable' 的超类型。

说明

#

当函数体具有 sync* 修饰符，但函数的返回类型既不是 Iterable 也不是 Iterable 的超类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 的体具有 'sync*' 修饰符，但返回类型 int 不是 Iterable 的超类型：

dart
int f() sync* {}

常规修复

#

如果函数应返回可迭代对象，则将返回类型更改为 Iterable 或 Iterable 的超类型：

dart
Iterable<int> f() sync* {}

如果函数应返回单个值，则删除 sync* 修饰符：

dart
int f() => 0;

implements_non_class

#

类和 mixin 只能实现其他类和 mixin。

说明

#

当类或 mixin 声明的 implements 子句中使用的名称被定义为非类或 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 是变量而不是类或 mixin：

dart
var x;
class C implements x {}

常规修复

#

如果名称是已导入的现有类或 mixin 的名称，则向导入添加前缀，以便名称的局部定义不会隐藏导入的名称。

如果名称是未导入的现有类或 mixin 的名称，则添加一个带有前缀的导入，用于声明它的库。

否则，请将 implements 子句中的名称替换为现有类或 mixin 的名称，或从 implements 子句中删除名称。

implements_repeated

#

' {0}' 只能实现一次。

说明

#

当在 implements 子句中多次指定单个类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 出现在列表中两次：

dart
class A {}
class B implements A, A {}

常规修复

#

删除类名，只保留一个：

dart
class A {}
class B implements A {}

implements_super_class

#

' {0}' 不能同时用于 'extends' 和 'implements' 子句中。

' {0}' 不能同时用于 'extends' 和 'with' 子句中。

说明

#

当类在类声明的 extends 子句中列出，并且也在相同声明的 implements 或 with 子句中列出时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 A 用于类 B 的 extends 和 implements 子句中：

dart
class A {}

class B extends A implements A {}

以下代码会生成此诊断信息，因为类 A 用于类 B 的 extends 和 with 子句中：

dart
mixin class A {}

class B extends A with A {}

常规修复

#

如果您想从类继承实现，则从 implements 子句中删除该类：

dart
class A {}

class B extends A {}

如果您不想从类继承实现，则删除 extends 子句：

dart
class A {}

class B implements A {}

implicit_super_initializer_missing_arguments

#

来自 '{0}' 的隐式调用的未命名构造函数具有必需参数。

说明

#

当构造函数隐式调用超类的未命名构造函数时，分析器会生成此诊断信息，超类的未命名构造函数具有必需参数，并且没有与必需参数对应的超类参数。

示例

#

以下代码会生成此诊断信息，因为类 B 中的未命名构造函数隐式调用类 A 中的未命名构造函数，但 A 中的构造函数具有名为 x 的必需位置参数：

dart
class A {
  A(int x);
}

class B extends A {
  B() ;
}

以下代码会生成此诊断信息，因为类 B 中的未命名构造函数隐式调用类 A 中的未命名构造函数，但 A 中的构造函数具有名为 x 的必需命名参数：

dart
class A {
  A({required int x});
}

class B extends A {
  B() ;
}

常规修复

#

如果可以向子类中的构造函数添加参数，则添加一个与超类构造函数中的必需参数对应的超类参数。新参数可以是必需的：

dart
class A {
  A({required int x});
}

class B extends A {
  B({required super.x});
}

或者它是可选的：

dart
class A {
  A({required int x});
}

class B extends A {
  B({super.x = 0});
}

如果无法向子类中的构造函数添加参数，则使用具有必需参数的显式超类构造函数调用：

dart
class A {
  A(int x);
}

class B extends A {
  B() : super(0);
}

implicit_this_reference_in_initializer

#

不能在初始化器中访问实例成员 '{0}'。

说明

#

当分析器在构造函数的初始化器列表中找到对实例成员的引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 defaultX 是实例成员：

dart
class C {
  int x;

  C() : x = defaultX;

  int get defaultX => 0;
}

常规修复

#

如果成员可以设为静态的，则这样做：

dart
class C {
  int x;

  C() : x = defaultX;

  static int get defaultX => 0;
}

如果不是，则将初始化器中的引用替换为不使用实例成员的不同表达式：

dart
class C {
  int x;

  C() : x = 0;

  int get defaultX => 0;
}

import_deferred_library_with_load_function

#

导入的库定义了一个名为 'loadLibrary' 的顶级函数，该函数被延迟此库隐藏了。

说明

#

说明

#

当声明名为 loadLibrary 的函数的库使用延迟导入导入时，分析器会生成此诊断信息。延迟导入会引入一个名为 loadLibrary 的隐式函数。此函数用于加载延迟加载库的内容，并且隐式函数隐藏了延迟加载库中显式声明的函数。

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

示例

#

给定一个定义名为 loadLibrary 的函数的文件 a.dart ：

dart
void loadLibrary(Library library) {}

class Library {}

以下代码会生成此诊断信息，因为 a.loadLibrary 的隐式声明隐藏了 a.dart 中 loadLibrary 的显式声明：

dart
import 'a.dart' deferred as a;

void f() {
  a.Library();
}

常规修复

#

如果不需要将导入的库延迟加载，则删除关键字 deferred ：

dart
import 'a.dart' as a;

void f() {
  a.Library();
}

如果需要将导入的库延迟加载并且您需要引用导入的函数，则重命名导入库中的函数：

dart
void populateLibrary(Library library) {}

class Library {}

如果需要将导入的库延迟加载并且您不需要引用导入的函数，则添加 hide 子句：

dart
import 'a.dart' deferred as a hide loadLibrary;

void f() {
  a.Library();
}

import_internal_library

#

库 '{0}' 是内部库，不能导入。

说明

#

当找到一个其 dart: URI 引用内部库的导入时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 _interceptors 是内部库：

dart
import 'dart:_interceptors';

常规修复

#

删除导入指令。

import_of_legacy_library_into_null_safe

#

库 '{0}' 是旧版库，不应导入到空安全库中。

说明

#

当空安全的库导入非空安全的库时，分析器会生成此诊断信息。

示例

#

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

dart
// @dart = 2.9

class A {}

以下代码会生成此诊断信息，因为空安全的库正在导入非空安全的库：

dart
import 'a.dart';

A? f() => null;

常规修复

#

如果您能够迁移导入的库使其成为空安全的，则迁移它并更新或删除迁移的库的语言版本。

如果您无法迁移导入的库，则导入库需要具有早于 2.12 的语言版本，因为空安全在 2.12 版本中默认启用。

import_of_non_library

#

导入的库 '{0}' 不能有 part-of 指令。

说明

#

当将 部分文件 导入库时，分析器会生成此诊断信息。

示例

#

给定一个名为 part.dart 的 部分文件 ，其中包含以下内容：

dart
part of lib;

以下代码会生成此诊断信息，因为导入的文件不能有 part-of 指令：

dart
library lib;

import 'part.dart';

常规修复

#

导入包含 部分文件 的库，而不是 部分文件 本身。

inconsistent_inheritance

#

超接口没有 '{0}' 的有效覆盖：{1}。

说明

#

当类继承成员的两个或多个冲突签名，并且没有提供满足所有继承签名的实现时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 继承了 A 中 m 的声明，并且该实现与从 B 继承的 m 的签名不一致：

dart
class A {
  void m({int? a}) {}
}

class B {
  void m({int? b}) {}
}

class C extends A implements B {
}

常规修复

#

添加一个满足所有继承签名的函数实现：

dart
class A {
  void m({int? a}) {}
}

class B {
  void m({int? b}) {}
}

class C extends A implements B {
  void m({int? a, int? b}) {}
}

inconsistent_language_version_override

#

部分必须与库具有完全相同的语言版本覆盖。

说明

#

当 部分文件 的语言版本覆盖注释指定的语言版本与属于该部分的库所使用的语言版本不同时，分析器会生成此诊断信息。

示例

#

给定一个名为 part.dart 的 部分文件 ，其中包含以下内容：

dart
// @dart = 2.14
part of 'test.dart';

以下代码会生成此诊断信息，因为库的部分必须与定义编译单元具有相同的语言版本：

dart
// @dart = 2.15
part 'part.dart';

常规修复

#

从 部分文件 中删除语言版本覆盖，以便它隐式地使用与定义编译单元相同的版本：

dart
part of 'test.dart';

如有必要，请调整定义编译单元中的语言版本覆盖以适合部分中的代码，或迁移 部分文件 中的代码以使其与新的语言版本一致。

inconsistent_pattern_variable_logical_or

#

变量 '{0}' 在逻辑或模式的此分支中具有不同的类型和/或 final 性。

说明

#

当逻辑或模式的所有分支上声明的模式变量在每个分支上没有相同的类型时，分析器会生成此诊断信息。当变量在不同分支上具有不同的 final 性时，也会生成此诊断信息。在逻辑或模式的多个分支上声明的模式变量需要在每个分支中具有相同的类型和 final 性，以便可以在受逻辑或模式保护的代码中知道变量的类型和 final 性。

示例

#

以下代码会生成此诊断信息，因为变量 a 在一个分支上被定义为 int ，而在另一个分支上被定义为 double ：

dart
void f(Object? x) {
  if (x case (int a) || (double a)) {
    print(a);
  }
}

以下代码会生成此诊断信息，因为变量 a 在第一个分支中是 final ，而在第二个分支中不是 final ：

dart
void f(Object? x) {
  if (x case (final int a) || (int a)) {
    print(a);
  }
}

常规修复

#

如果变量的 final 性不同，则决定它应该是 final 还是非 final ，并使情况保持一致：

dart
void f(Object? x) {
  if (x case (int a) || (int a)) {
    print(a);
  }
}

如果变量的类型不同并且类型对于要匹配的条件并不重要，则确保变量在两个分支上都具有相同的类型：

dart
void f(Object? x) {
  if (x case (num a) || (num a)) {
    print(a);
  }
}

如果变量的类型不同并且类型对于要匹配的条件至关重要，则考虑将条件分解为多个 if 语句或 case 子句：

dart
void f(Object? x) {
  if (x case int a) {
    print(a);
  } else if (x case double a) {
    print(a);
  }
}

initializer_for_non_existent_field

#

' {0}' 不是封闭类中的字段。

说明

#

当构造函数初始化在包含构造函数的类中未声明的字段时，分析器会生成此诊断信息。构造函数不能初始化未声明的字段和从超类继承的字段。

示例

#

以下代码会生成此诊断信息，因为初始化器正在初始化 x ，但 x 不是类中的字段：

dart
class C {
  int? y;

  C() : x = 0;
}

常规修复

#

如果应初始化不同的字段，则将名称更改为字段的名称：

dart
class C {
  int? y;

  C() : y = 0;
}

如果必须声明该字段，则添加声明：

dart
class C {
  int? x;
  int? y;

  C() : x = 0;
}

initializer_for_static_field

#

' {0}' 是封闭类中的静态字段。在构造函数中初始化的字段不能是静态的。

说明

#

当使用初始化形式参数或初始化器列表中的赋值在构造函数中初始化静态字段时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为静态字段 a 由初始化形式参数 this.a 初始化：

dart
class C {
  static int? a;
  C(this.a);
}

常规修复

#

如果字段应该是实例字段，则删除关键字 static ：

dart
class C {
  int? a;
  C(this.a);
}

如果您打算初始化实例字段并键入错误的名称，则更正正在初始化的字段的名称：

dart
class C {
  static int? a;
  int? b;
  C(this.b);
}

如果您确实要初始化静态字段，则将初始化移到构造函数体中：

dart
class C {
  static int? a;
  C(int? c) {
    a = c;
  }
}

initializing_formal_for_non_existent_field

#

' {0}' 不是封闭类中的字段。

说明

#

当在未声明要初始化的字段的类的构造函数中找到初始化形式参数时，分析器会生成此诊断信息。构造函数不能初始化未声明的字段和从超类继承的字段。

示例

#

以下代码会生成此诊断信息，因为字段 x 未定义：

dart
class C {
  int? y;

  C(this.x);
}

常规修复

#

如果字段名称错误，则将其更改为现有字段的名称：

dart
class C {
  int? y;

  C(this.y);
}

如果字段名称正确但尚未定义，则声明该字段：

dart
class C {
  int? x;
  int? y;

  C(this.x);
}

如果需要参数但它不应该初始化字段，则将其转换为普通参数并使用它：

dart
class C {
  int y;

  C(int x) : y = x * 2;
}

如果不需要参数，则将其删除：

dart
class C {
  int? y;

  C();
}

instance_access_to_static_member

#

不能通过实例访问静态 {1} '{0}'。

说明

#

当使用访问运算符通过类的实例访问静态成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 zero 是静态字段，但它被访问的方式好像它是实例字段：

dart
void f(C c) {
  c.zero;
}

class C {
  static int zero = 0;
}

常规修复

#

使用类访问静态成员：

dart
void f(C c) {
  C.zero;
}

class C {
  static int zero = 0;
}

instance_member_access_from_factory

#

不能从工厂构造函数访问实例成员。

说明

#

当工厂构造函数包含对实例成员的非限定引用时，分析器会生成此诊断信息。在生成式构造函数中，类的实例在执行构造函数体之前创建并初始化，因此实例可以绑定到 this 并像在实例方法中一样访问。但是，在工厂构造函数中，实例不是在执行主体之前创建的，因此 this 不能用于引用它。

示例

#

以下代码会生成此诊断信息，因为 x 在工厂构造函数中不在作用域内：

dart
class C {
  int x;
  factory C() {
    return C._(x);
  }
  C._(this.x);
}

常规修复

#

重写代码，使其不引用实例成员：

dart
class C {
  int x;
  factory C() {
    return C._(0);
  }
  C._(this.x);
}

示例

#

以下代码会生成此诊断信息，因为实例字段 x 在静态方法中被引用：

dart
class C {
  int x = 0;

  static int m() {
    return x;
  }
}

常规修复

#

如果该方法必须引用实例成员，则它不能是静态的，因此删除关键字：

dart
class C {
  int x = 0;

  int m() {
    return x;
  }
}

如果该方法不能设为实例方法，则添加一个参数，以便可以传入类的实例：

dart
class C {
  int x = 0;

  static int m(C c) {
    return c.x;
  }
}

instantiate_abstract_class

#

不能实例化抽象类。

说明

#

当找到构造函数调用，并且该构造函数在抽象类中声明时，分析器会生成此诊断信息。即使您无法创建抽象类的实例，抽象类也可以声明可以由子类调用的构造函数。

示例

#

以下代码会生成此诊断信息，因为 C 是抽象类：

dart
abstract class C {}

var c = new C() ;

常规修复

#

如果有可以使用的抽象类的具体子类，则创建具体子类的实例。

instantiate_enum

#

不能实例化枚举。

说明

#

当实例化枚举时，分析器会生成此诊断信息。通过调用构造函数来创建枚举的实例是无效的；只有在枚举的声明中命名的实例才能存在。

示例

#

以下代码会生成此诊断信息，因为枚举 E 正在被实例化：

dart
// @dart = 2.16
enum E {a}

var e = E() ;

常规修复

#

如果您打算使用枚举的实例，则引用枚举中定义的常量之一：

dart
// @dart = 2.16
enum E {a}

var e = E.a;

如果您打算使用类的实例，则使用该类的名称代替枚举的名称。

instantiate_type_alias_expands_to_type_parameter

#

扩展为类型参数的类型别名不能实例化。

说明

#

当找到构造函数调用，并且要实例化的类型是类型参数的类型别名时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为它创建了 A 的实例，即使 A 是一个类型别名，它被定义为等同于类型参数：

dart
typedef A<T> = T;

void f() {
  const A<int>();
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
typedef A<T> = C<T>;

void f() {
  const A<int>();
}

class C<T> {
  const C();
}

integer_literal_imprecise_as_double

#

整数字面量用作双精度浮点数，但不能在不溢出或损失精度的情况下表示为 64 位双精度浮点数：'{0}'。

说明

#

当整数字面量被隐式转换为双精度浮点数，但不能在不溢出或损失精度的情况下表示为 64 位双精度浮点数时，分析器会生成此诊断信息。如果上下文需要类型 double ，则整数字面量将被隐式转换为双精度浮点数。

示例

#

以下代码会生成此诊断信息，因为整数 9223372036854775807 不能精确地表示为双精度浮点数：

dart
double x = 9223372036854775807;

常规修复

#

如果您需要使用精确值，则使用类 BigInt 来表示该值：

dart
var x = BigInt.parse('9223372036854775807');

如果您需要使用双精度浮点数，则将值更改为可以精确表示的值：

dart
double x = 9223372036854775808;

integer_literal_out_of_range

#

整数字面量 {0} 不能用 64 位表示。

说明

#

当整数字面量的值太大（正数）或太小（负数）而无法用 64 位字表示时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为该值不能用 64 位表示：

dart
var x = 9223372036854775810;

常规修复

#

如果您需要表示当前值，则将其包装在类 BigInt 的实例中：

dart
var x = BigInt.parse('9223372036854775810');

invalid_annotation

#

注解必须是 const 变量引用或 const 构造函数调用。

说明

#

当找到既不是标记为 const 的变量也不是 const 构造函数的调用的注解时，分析器会生成此诊断信息。

getter 不能用作注解。

示例

#

以下代码会生成此诊断信息，因为变量 v 不是 const 变量：

dart
var v = 0;

@v
void f() {
}

以下代码会生成此诊断信息，因为 f 不是变量：

dart
@f
void f() {
}

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

dart
@f()
void f() {
}

以下代码会生成此诊断信息，因为 g 是 getter：

dart
@g
int get g => 0;

常规修复

#

如果注解引用的是不是 const 构造函数的变量，则向变量的声明中添加关键字 const ：

dart
const v = 0;

@v
void f() {
}

如果注解没有引用变量，则将其删除：

dart
int v = 0;

void f() {
}

invalid_annotation_constant_value_from_deferred_library

#

来自延迟加载库的常量值不能用于注解中。

说明

#

当作为延迟加载库导入的库中定义的常量在注解的参数列表中被引用时，分析器会生成此诊断信息。注解在编译时计算，而来自延迟加载库的值在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为常量 pi 在注解的参数列表中被引用，即使定义它的库被导入为延迟加载库：

dart
import 'dart:math' deferred as math;

class C {
  const C(double d);
}

@C(math.pi)
void f () {}

常规修复

#

如果您需要引用导入的常量，则删除 deferred 关键字：

dart
import 'dart:math' as math;

class C {
  const C(double d);
}

@C(math.pi)
void f () {}

如果需要延迟导入，并且还有其他合适的常量，则使用该常量代替延迟加载库中的常量。

invalid_annotation_from_deferred_library

#

来自延迟加载库的常量值不能用作注解。

说明

#

当使用延迟导入导入的库中的常量用作注解时，分析器会生成此诊断信息。注解在编译时计算，而来自延迟加载库的常量在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为当库 dart:math 作为 deferred 导入时，常量 pi 用作注解：

dart
import 'dart:math' deferred as math;

@math.pi
void f() {}

常规修复

#

如果您需要将常量用作注解，则从导入中删除关键字 deferred ：

dart
import 'dart:math' as math;

@math.pi
void f() {}

如果您可以使用不同的常量作为注解，则将注解替换为不同的常量：

dart
@deprecated
void f() {}

invalid_annotation_target

#

注解 '{0}' 只能用于 {1} 上。

说明

#

当注解应用于它不支持的声明类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 optionalTypeArgs 注解未定义为对顶级变量有效：

dart
import 'package:meta/meta.dart';

@optionalTypeArgs
int x = 0;

常规修复

#

从声明中删除注解。

invalid_assignment

#

类型为 '{0}' 的值无法赋值给类型为 '{1}' 的变量。

说明

#

当赋值给变量的表达式的静态类型无法赋值给变量的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为初始化器的类型（ int ）无法赋值给变量的类型（ String ）：

dart
int i = 0;
String s = i;

常规修复

#

如果值在运行时始终可赋值，即使静态类型没有反映这一点，则添加显式强制转换。

否则，更改正在赋值的值，使其具有预期的类型。在上一个示例中，这可能看起来像这样：

dart
int i = 0;
String s = i.toString();

如果您无法更改值，则更改变量的类型以使其与正在赋值的值的类型兼容：

dart
int i = 0;
int s = i;

invalid_dependency

#

可发布的包不能有 '{0}' 依赖项。

说明

#

当可发布的包在其 pubspec.yaml 文件的 dependencies 列表中包含不是 pub 托管依赖项的包时，分析器会生成此诊断信息。

要了解有关不同类型依赖项源的更多信息，请查看 包依赖项 。

示例

#

以下代码会生成此诊断信息，因为对包 transmogrify 的依赖不是 pub 托管依赖项。

yaml
name: example
dependencies:
  transmogrify:
    path: ../transmogrify

常规修复

#

如果您想将包发布到 pub.dev ，则将依赖项更改为发布在 pub.dev 上的托管包。

如果该包不打算发布到 pub.dev ，则向其 pubspec.yaml 文件添加一个 publish_to: none 条目以将其标记为不打算发布：

yaml
name: example
publish_to: none
dependencies:
  transmogrify:
    path: ../transmogrify

invalid_exception_value

#

当函数的返回类型为 'void'、'Handle' 或 'Pointer' 时，方法 {0} 不能有异常返回值（第二个参数）。

说明

#

当 Pointer.fromFunction 或 NativeCallable.isolateLocal 的调用具有第二个参数（异常返回值），并且从调用返回的类型是 void 、 Handle 或 Pointer 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为在 f 的返回类型为 void 时提供了第二个参数：

dart
import 'dart:ffi';

typedef T = Void Function(Int8);

void f(int i) {}

void g() {
  Pointer.fromFunction<T>(f, 42);
}

常规修复

#

删除异常值：

dart
import 'dart:ffi';

typedef T = Void Function(Int8);

void f(int i) {}

void g() {
  Pointer.fromFunction<T>(f);
}

invalid_export_of_internal_element

#

成员 '{0}' 不能导出为包的公共 API 的一部分。

说明

#

说明

#

当使用延迟导入导入声明名为 loadLibrary 的函数的库时，分析器会生成此诊断信息。延迟导入会引入一个名为 loadLibrary 的隐式函数。此函数用于加载延迟加载库的内容，并且隐式函数会隐藏延迟加载库中显式声明的函数。

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

示例

#

给定一个定义名为 loadLibrary 的函数的文件 a.dart ：

dart
void loadLibrary(Library library) {}

class Library {}

以下代码会生成此诊断信息，因为 a.loadLibrary 的隐式声明隐藏了 a.dart 中 loadLibrary 的显式声明：

dart
import 'a.dart' deferred as a;

void f() {
  a.Library();
}

常规修复

#

如果不需要将导入的库延迟加载，则删除关键字 deferred ：

dart
import 'a.dart' as a;

void f() {
  a.Library();
}

如果需要将导入的库延迟加载并且您需要引用导入的函数，则重命名导入库中的函数：

dart
void populateLibrary(Library library) {}

class Library {}

如果需要将导入的库延迟加载并且您不需要引用导入的函数，则添加 hide 子句：

dart
import 'a.dart' deferred as a hide loadLibrary;

void f() {
  a.Library();
}

import_internal_library

#

库 '{0}' 是内部库，不能导入。

说明

#

当找到一个其 dart: URI 引用内部库的导入时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 _interceptors 是内部库：

dart
import 'dart:_interceptors';

常规修复

#

删除导入指令。

import_of_legacy_library_into_null_safe

#

库 '{0}' 是旧版库，不应导入到空安全库中。

说明

#

当空安全的库导入非空安全的库时，分析器会生成此诊断信息。

示例

#

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

dart
// @dart = 2.9

class A {}

以下代码会生成此诊断信息，因为空安全的库正在导入非空安全的库：

dart
import 'a.dart';

A? f() => null;

常规修复

#

如果您能够迁移导入的库使其成为空安全的，则迁移它并更新或删除迁移的库的语言版本。

如果您无法迁移导入的库，则导入库需要具有早于 2.12 的语言版本，因为空安全在 2.12 版本中默认启用。

import_of_non_library

#

导入的库 '{0}' 不能有 part-of 指令。

说明

#

当将 部分文件 导入库时，分析器会生成此诊断信息。

示例

#

给定一个名为 part.dart 的 部分文件 ，其中包含以下内容：

dart
part of lib;

以下代码会生成此诊断信息，因为导入的文件不能有 part-of 指令：

dart
library lib;

import 'part.dart';

常规修复

#

导入包含 部分文件 的库，而不是 部分文件 本身。

inconsistent_inheritance

#

超接口没有 '{0}' 的有效覆盖：{1}。

说明

#

当类继承成员的两个或多个冲突签名，并且没有提供满足所有继承签名的实现时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 继承了 A 中 m 的声明，并且该实现与从 B 继承的 m 的签名不一致：

dart
class A {
  void m({int? a}) {}
}

class B {
  void m({int? b}) {}
}

class C extends A implements B {
}

常规修复

#

添加一个满足所有继承签名的函数实现：

dart
class A {
  void m({int? a}) {}
}

class B {
  void m({int? b}) {}
}

class C extends A implements B {
  void m({int? a, int? b}) {}
}

inconsistent_language_version_override

#

部分必须与库具有完全相同的语言版本覆盖。

说明

#

当 部分文件 的语言版本覆盖注释指定的语言版本与属于该部分的库所使用的语言版本不同时，分析器会生成此诊断信息。

示例

#

给定一个名为 part.dart 的 部分文件 ，其中包含以下内容：

dart
// @dart = 2.14
part of 'test.dart';

以下代码会生成此诊断信息，因为库的部分必须与定义编译单元具有相同的语言版本：

dart
// @dart = 2.15
part 'part.dart';

常规修复

#

从 部分文件 中删除语言版本覆盖，以便它隐式地使用与定义编译单元相同的版本：

dart
part of 'test.dart';

如有必要，请调整定义编译单元中的语言版本覆盖以适合部分中的代码，或迁移 部分文件 中的代码以使其与新的语言版本一致。

inconsistent_pattern_variable_logical_or

#

变量 '{0}' 在逻辑或模式的此分支中具有不同的类型和/或 final 性。

说明

#

当逻辑或模式的所有分支上声明的模式变量在每个分支上没有相同的类型时，分析器会生成此诊断信息。当变量在不同分支上具有不同的 final 性时，也会生成此诊断信息。在逻辑或模式的多个分支上声明的模式变量需要在每个分支中具有相同的类型和 final 性，以便可以在受逻辑或模式保护的代码中知道变量的类型和 final 性。

示例

#

以下代码会生成此诊断信息，因为变量 a 在一个分支上被定义为 int ，而在另一个分支上被定义为 double ：

dart
void f(Object? x) {
  if (x case (int a) || (double a)) {
    print(a);
  }
}

以下代码会生成此诊断信息，因为变量 a 在第一个分支中是 final ，而在第二个分支中不是 final ：

dart
void f(Object? x) {
  if (x case (final int a) || (int a)) {
    print(a);
  }
}

常规修复

#

如果变量的 final 性不同，则决定它应该是 final 还是非 final ，并使情况保持一致：

dart
void f(Object? x) {
  if (x case (int a) || (int a)) {
    print(a);
  }
}

如果变量的类型不同并且类型对于要匹配的条件并不重要，则确保变量在两个分支上都具有相同的类型：

dart
void f(Object? x) {
  if (x case (num a) || (num a)) {
    print(a);
  }
}

如果变量的类型不同并且类型对于要匹配的条件至关重要，则考虑将条件分解为多个 if 语句或 case 子句：

dart
void f(Object? x) {
  if (x case int a) {
    print(a);
  } else if (x case double a) {
    print(a);
  }
}

initializer_for_non_existent_field

#

' {0}' 不是封闭类中的字段。

说明

#

当构造函数初始化在包含构造函数的类中未声明的字段时，分析器会生成此诊断信息。构造函数不能初始化未声明的字段和从超类继承的字段。

示例

#

以下代码会生成此诊断信息，因为初始化器正在初始化 x ，但 x 不是类中的字段：

dart
class C {
  int? y;

  C() : x = 0;
}

常规修复

#

如果应初始化不同的字段，则将名称更改为字段的名称：

dart
class C {
  int? y;

  C() : y = 0;
}

如果必须声明该字段，则添加声明：

dart
class C {
  int? x;
  int? y;

  C() : x = 0;
}

initializer_for_static_field

#

' {0}' 是封闭类中的静态字段。在构造函数中初始化的字段不能是静态的。

说明

#

当使用初始化形式参数或初始化器列表中的赋值在构造函数中初始化静态字段时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为静态字段 a 由初始化形式参数 this.a 初始化：

dart
class C {
  static int? a;
  C(this.a);
}

常规修复

#

如果字段应该是实例字段，则删除关键字 static ：

dart
class C {
  int? a;
  C(this.a);
}

如果您打算初始化实例字段并键入错误的名称，则更正正在初始化的字段的名称：

dart
class C {
  static int? a;
  int? b;
  C(this.b);
}

如果您确实要初始化静态字段，则将初始化移到构造函数体中：

dart
class C {
  static int? a;
  C(int? c) {
    a = c;
  }
}

initializing_formal_for_non_existent_field

#

' {0}' 不是封闭类中的字段。

说明

#

当在未声明要初始化的字段的类的构造函数中找到初始化形式参数时，分析器会生成此诊断信息。构造函数不能初始化未声明的字段和从超类继承的字段。

示例

#

以下代码会生成此诊断信息，因为字段 x 未定义：

dart
class C {
  int? y;

  C(this.x);
}

常规修复

#

如果字段名称错误，则将其更改为现有字段的名称：

dart
class C {
  int? y;

  C(this.y);
}

如果字段名称正确但尚未定义，则声明该字段：

dart
class C {
  int? x;
  int? y;

  C(this.x);
}

如果需要参数但它不应该初始化字段，则将其转换为普通参数并使用它：

dart
class C {
  int y;

  C(int x) : y = x * 2;
}

如果不需要参数，则将其删除：

dart
class C {
  int? y;

  C();
}

instance_access_to_static_member

#

不能通过实例访问静态 {1} '{0}'。

说明

#

当使用访问运算符通过类的实例访问静态成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 zero 是静态字段，但它被访问的方式好像它是实例字段：

dart
void f(C c) {
  c.zero;
}

class C {
  static int zero = 0;
}

常规修复

#

使用类访问静态成员：

dart
void f(C c) {
  C.zero;
}

class C {
  static int zero = 0;
}

instance_member_access_from_static

#

不能从静态方法访问实例成员。

说明

#

当静态方法包含对实例成员的非限定引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为实例字段 x 在静态方法中被引用：

dart
class C {
  int x = 0;

  static int m() {
    return x;
  }
}

常规修复

#

如果该方法必须引用实例成员，则它不能是静态的，因此删除关键字：

dart
class C {
  int x = 0;

  int m() {
    return x;
  }
}

如果该方法不能设为实例方法，则添加一个参数，以便可以传入类的实例：

dart
class C {
  int x = 0;

  static int m(C c) {
    return c.x;
  }
}

instantiate_abstract_class

#

不能实例化抽象类。

说明

#

当找到构造函数调用，并且该构造函数在抽象类中声明时，分析器会生成此诊断信息。即使您无法创建抽象类的实例，抽象类也可以声明可以由子类调用的构造函数。

示例

#

以下代码会生成此诊断信息，因为 C 是抽象类：

dart
abstract class C {}

var c = new C() ;

常规修复

#

如果有可以使用的抽象类的具体子类，则创建具体子类的实例。

instantiate_enum

#

不能实例化枚举。

说明

#

当实例化枚举时，分析器会生成此诊断信息。通过调用构造函数来创建枚举的实例是无效的；只有在枚举的声明中命名的实例才能存在。

示例

#

以下代码会生成此诊断信息，因为枚举 E 正在被实例化：

dart
// @dart = 2.16
enum E {a}

var e = E() ;

常规修复

#

如果您打算使用枚举的实例，则引用枚举中定义的常量之一：

dart
// @dart = 2.16
enum E {a}

var e = E.a;

如果您打算使用类的实例，则使用该类的名称代替枚举的名称。

instantiate_type_alias_expands_to_type_parameter

#

扩展为类型参数的类型别名不能实例化。

说明

#

当找到构造函数调用，并且要实例化的类型是类型参数的类型别名时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为它创建了 A 的实例，即使 A 是一个类型别名，它被定义为等同于类型参数：

dart
typedef A<T> = T;

void f() {
  const A<int>();
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
typedef A<T> = C<T>;

void f() {
  const A<int>();
}

class C<T> {
  const C();
}

integer_literal_imprecise_as_double

#

整数字面量用作双精度浮点数，但不能在不溢出或损失精度的情况下表示为 64 位双精度浮点数：'{0}'。

说明

#

当整数字面量被隐式转换为双精度浮点数，但不能在不溢出或损失精度的情况下表示为 64 位双精度浮点数时，分析器会生成此诊断信息。如果上下文需要类型 double ，则整数字面量将被隐式转换为双精度浮点数。

示例

#

以下代码会生成此诊断信息，因为整数值 9223372036854775807 不能精确地表示为双精度浮点数：

dart
double x = 9223372036854775807;

常规修复

#

如果您需要使用精确值，则使用类 BigInt 来表示该值：

dart
var x = BigInt.parse('9223372036854775807');

如果您需要使用双精度浮点数，则将值更改为可以精确表示的值：

dart
double x = 9223372036854775808;

integer_literal_out_of_range

#

整数字面量 {0} 不能用 64 位表示。

说明

#

当整数字面量的值太大（正数）或太小（负数）而无法用 64 位字表示时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为该值不能用 64 位表示：

dart
var x = 9223372036854775810;

常规修复

#

如果您需要表示当前值，则将其包装在类 BigInt 的实例中：

dart
var x = BigInt.parse('9223372036854775810');

invalid_annotation

#

注解必须是 const 变量引用或 const 构造函数调用。

说明

#

当找到既不是标记为 const 的变量也不是 const 构造函数的调用的注解时，分析器会生成此诊断信息。

getter 不能用作注解。

示例

#

以下代码会生成此诊断信息，因为变量 v 不是 const 变量：

dart
var v = 0;

@v
void f() {
}

以下代码会生成此诊断信息，因为 f 不是变量：

dart
@f
void f() {
}

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

dart
@f()
void f() {
}

以下代码会生成此诊断信息，因为 g 是 getter：

dart
@g
int get g => 0;

常规修复

#

如果注解引用的是不是 const 构造函数的变量，则向变量的声明中添加关键字 const ：

dart
const v = 0;

@v
void f() {
}

如果注解没有引用变量，则将其删除：

dart
int v = 0;

void f() {
}

invalid_annotation_constant_value_from_deferred_library

#

来自延迟加载库的常量值不能用于注解中。

说明

#

当作为延迟加载库导入的库中定义的常量在注解的参数列表中被引用时，分析器会生成此诊断信息。注解在编译时计算，而来自延迟加载库的值在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为常量 pi 在注解的参数列表中被引用，即使定义它的库被导入为延迟加载库：

dart
import 'dart:math' deferred as math;

class C {
  const C(double d);
}

@C(math.pi)
void f () {}

常规修复

#

如果您需要引用导入的常量，则删除 deferred 关键字：

dart
import 'dart:math' as math;

class C {
  const C(double d);
}

@C(math.pi)
void f () {}

如果需要延迟导入，并且还有其他合适的常量，则使用该常量代替延迟加载库中的常量。

invalid_annotation_from_deferred_library

#

来自延迟加载库的常量值不能用作注解。

说明

#

当使用延迟导入导入的库中的常量用作注解时，分析器会生成此诊断信息。注解在编译时计算，而来自延迟加载库的常量在编译时不可用。

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

示例

#

以下代码会生成此诊断信息，因为常量 pi 用作注解，而库 dart:math 作为 deferred 导入：

dart
import 'dart:math' deferred as math;

@math.pi
void f() {}

常规修复

#

如果您需要将常量用作注解，则从导入中删除关键字 deferred ：

dart
import 'dart:math' as math;

@math.pi
void f() {}

如果您可以使用不同的常量作为注解，则将注解替换为不同的常量：

dart
@deprecated
void f() {}

invalid_annotation_target

#

注解 '{0}' 只能用于 {1} 上。

说明

#

当注解应用于它不支持的声明类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 optionalTypeArgs 注解未定义为对顶级变量有效：

dart
import 'package:meta/meta.dart';

@optionalTypeArgs
int x = 0;

常规修复

#

从声明中删除注解。

invalid_assignment

#

类型为 '{0}' 的值无法赋值给类型为 '{1}' 的变量。

说明

#

当赋值给变量的表达式的静态类型无法赋值给变量的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为初始化器的类型（ int ）无法赋值给变量的类型（ String ）：

dart
int i = 0;
String s = i;

常规修复

#

如果值在运行时始终可赋值，即使静态类型没有反映这一点，则添加显式强制转换。

否则，更改正在赋值的值，使其具有预期的类型。在上一个示例中，这可能看起来像这样：

dart
int i = 0;
String s = i.toString();

如果您无法更改值，则更改变量的类型以使其与正在赋值的值的类型兼容：

dart
int i = 0;
int s = i;

invalid_dependency

#

可发布的包不能有 '{0}' 依赖项。

说明

#

当可发布的包在其 pubspec.yaml 文件的 dependencies 列表中包含不是 pub 托管依赖项的包时，分析器会生成此诊断信息。

要了解有关不同类型依赖项源的更多信息，请查看 包依赖项 。

示例

#

以下代码会生成此诊断信息，因为对包 transmogrify 的依赖不是 pub 托管依赖项。

yaml
name: example
dependencies:
  transmogrify:
    path: ../transmogrify

常规修复

#

如果您想将包发布到 pub.dev ，则将依赖项更改为发布在 pub.dev 上的托管包。

如果该包不打算发布到 pub.dev ，则向其 pubspec.yaml 文件添加一个 publish_to: none 条目以将其标记为不打算发布：

yaml
name: example
publish_to: none
dependencies:
  transmogrify:
    path: ../transmogrify

invalid_exception_value

#

当函数的返回类型为 'void'、'Handle' 或 'Pointer' 时，方法 {0} 不能有异常返回值（第二个参数）。

说明

#

当 Pointer.fromFunction 或 NativeCallable.isolateLocal 的调用具有第二个参数（异常返回值），并且从调用返回的类型是 void 、 Handle 或 Pointer 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为在 f 的返回类型为 void 时提供了第二个参数：

dart
import 'dart:ffi';

typedef T = Void Function(Int8);

void f(int i) {}

void g() {
  Pointer.fromFunction<T>(f, 42);
}

常规修复

#

删除异常值：

dart
import 'dart:ffi';

typedef T = Void Function(Int8);

void f(int i) {}

void g() {
  Pointer.fromFunction<T>(f);
}

invalid_export_of_internal_element

#

成员 '{0}' 不能导出为包的公共 API 的一部分。

说明

#

当 公共库 导出用 internal 注解标记的声明时，分析器会生成此诊断信息。

示例

#

给定 src 目录中的一个文件 a.dart ，其中包含：

dart
import 'package:meta/meta.dart';

@internal class One {}

以下代码，当在 公共库 中找到时，会生成此诊断信息，因为 export 指令正在导出仅用于内部的名称：

dart
export 'src/a.dart';

常规修复

#

如果需要导出，则添加 hide 子句以隐藏内部名称：

dart
export 'src/a.dart' hide One;

如果不需要导出，则将其删除。

invalid_export_of_internal_element_indirectly

#

成员 '{0}' 不能导出为包的公共 API 的一部分，但作为 '{1}' 的签名的间接导出。

说明

#

当 公共库 导出返回类型或至少一个参数类型用 internal 注解标记的顶级函数时，分析器会生成此诊断信息。

示例

#

给定 src 目录中的一个文件 a.dart ，其中包含以下内容：

dart
import 'package:meta/meta.dart';

@internal
typedef IntFunction = int Function();

int f(IntFunction g) => g();

以下代码会生成此诊断信息，因为函数 f 的参数类型为 IntFunction ，而 IntFunction 仅用于内部：

dart
export 'src/a.dart' show f;

常规修复

#

如果该函数必须是公共的，则使函数签名中的所有类型都成为公共类型。

如果不需要导出该函数，则停止导出它，方法是从 show 子句中将其删除，将其添加到 hide 子句中，或删除导出。

invalid_extension_argument_count

#

扩展重写必须恰好有一个参数：扩展方法中 'this' 的值。

说明

#

当扩展重写没有恰好一个参数时，分析器会生成此诊断信息。该参数是用于计算扩展方法中 this 值的表达式，因此必须有一个参数。

示例

#

以下代码会生成此诊断信息，因为没有参数：

dart
extension E on String {
  String join(String other) => '$this $other';
}

void f() {
  E().join('b');
}

并且，以下代码会生成此诊断信息，因为存在多个参数：

dart
extension E on String {
  String join(String other) => '$this $other';
}

void f() {
  E('a', 'b').join('c');
}

常规修复

#

为扩展重写提供一个参数：

dart
extension E on String {
  String join(String other) => '$this $other';
}

void f() {
  E('a').join('b');
}

invalid_factory_method_decl

#

工厂方法 '{0}' 必须有返回类型。

说明

#

当用 factory 注解注释的方法的返回类型为 void 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为方法 createC 用 factory 注解注释，但没有返回值：

dart
import 'package:meta/meta.dart';

class Factory {
  @factory
  void createC() {}
}

class C {}

常规修复

#

将返回类型更改为除 void 之外的其他类型：

dart
import 'package:meta/meta.dart';

class Factory {
  @factory
  C createC() => C();
}

class C {}

invalid_factory_method_impl

#

工厂方法 '{0}' 没有返回新分配的对象。

说明

#

当用 factory 注解注释的方法没有返回新分配的对象时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为方法 createC 返回字段的值，而不是新创建的 C 实例：

dart
import 'package:meta/meta.dart';

class Factory {
  C c = C();

  @factory
  C createC() => c;
}

class C {}

常规修复

#

更改该方法以返回新创建的返回类型的实例：

dart
import 'package:meta/meta.dart';

class Factory {
  @factory
  C createC() => C();
}

class C {}

invalid_factory_name_not_a_class

#

工厂构造函数的名称必须与紧邻的类的名称相同。

说明

#

当工厂构造函数的名称与周围类的名称不同时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为工厂构造函数的名称（ A ）与周围类（ C ）的名称不同：

dart
class A {}

class C {
  factory A() => throw 0;
}

常规修复

#

如果工厂返回周围类的实例，并且您希望它是一个未命名的工厂构造函数，则重命名工厂：

dart
class A {}

class C {
  factory C() => throw 0;
}

如果工厂返回周围类的实例，并且您希望它是一个命名的工厂构造函数，则在工厂构造函数的名称前加上周围类的名称：

dart
class A {}

class C {
  factory C.a() => throw 0;
}

如果工厂返回不同类的实例，则将工厂移动到该类：

dart
class A {
  factory A() => throw 0;
}

class C {}

如果工厂返回不同类的实例，但您无法修改该类或不想移动工厂，则将其转换为静态方法：

dart
class A {}

class C {
  static A a() => throw 0;
}

invalid_field_name

#

当整数是位置字段的索引时，记录字段名不能是美元符号后跟整数。

记录字段名不能是私有的。

记录字段名不能与 'Object' 的成员相同。

说明

#

当记录字面量或记录类型注解的字段名称无效时，分析器会生成此诊断信息。如果名称是：

  • 私有的（以 _ 开头）
  • 与 Object 上定义的成员之一相同
  • 与位置字段的名称相同（如果字段是具有指定名称的位置字段，则会例外）

示例

#

以下代码会生成此诊断信息，因为记录字面量有一个名为 toString 的字段，它是 Object 上定义的方法：

dart
var r = (a: 1, toString: 4);

以下代码会生成此诊断信息，因为记录类型注解有一个名为 hashCode 的字段，它是 Object 上定义的 getter：

dart
void f(({int a, int hashCode}) r) {}

以下代码会生成此诊断信息，因为记录字面量有一个名为 _a 的私有字段：

dart
var r = (_a: 1, b: 2);

以下代码会生成此诊断信息，因为记录类型注解有一个名为 _a 的私有字段：

dart
void f(({int _a, int b}) r) {}

以下代码会生成此诊断信息，因为记录字面量有一个名为 $1 的字段，它也是不同的位置参数的名称：

dart
var r = (2, $1: 1);

以下代码会生成此诊断信息，因为记录类型注解有一个名为 $1 的字段，它也是不同的位置参数的名称：

dart
void f((int, String, {int $1}) r) {}

常规修复

#

重命名字段：

dart
var r = (a: 1, d: 4);

invalid_field_type_in_struct

#

结构体类中的字段不能具有类型 '{0}'。它们只能声明为 'int'、'double'、'Array'、'Pointer' 或 'Struct' 或 'Union' 的子类型。

说明

#

当 Struct 的子类中的字段的类型不是 int 、 double 、 Array 、 Pointer 或 Struct 或 Union 的子类型时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 str 的类型为 String ，它不是 Struct 的子类的允许类型之一：

dart
import 'dart:ffi';

final class C extends Struct {
  external String s;

  @Int32()
  external int i;
}

常规修复

#

对字段使用允许的类型之一：

dart
import 'dart:ffi';
import 'package:ffi/ffi.dart';

final class C extends Struct {
  external Pointer<Utf8> s;

  @Int32()
  external int i;
}

invalid_implementation_override

#

' {1}.{0}' ('{2}') 不是 '{3}.{0}' ('{4}') 的有效具体实现。

setter '{1}.{0}' ('{2}') 不是 '{3}.{0}' ('{4}') 的有效具体实现。

说明

#

当满足以下所有条件时，分析器会生成此诊断信息：

  • 类定义了一个抽象成员。
  • 超类中存在该成员的具体实现。
  • 具体实现不是抽象方法的有效实现。

具体实现可能无效，因为返回类型、方法参数的类型或类型参数不兼容#### 说明

当用 internal 注解注释的声明位于 公共库 中或具有私有名称时，分析器会生成此诊断信息。

示例

#

以下代码，当在 公共库 中时，会生成此诊断信息，因为 internal 注解不能应用于 公共库 中的声明：

dart
import 'package:meta/meta.dart';

@internal
class C {}

以下代码，无论是在公共库还是内部库中，都会生成此诊断信息，因为 internal 注解不能应用于具有私有名称的声明：

dart
import 'package:meta/meta.dart';

@internal
class _C {}

void f(_C c) {}

常规修复

#

如果声明具有私有名称，则删除注解：

dart
class _C {}

void f(_C c) {}

如果声明具有公共名称并且旨在作为包的内部内容，则将带注解的声明移到内部库（换句话说，是 src 目录内的库）。

否则，删除注解的使用：

dart
class C {}

invalid_language_version_override

#

Dart 语言版本覆盖注释后不能有任何非空白字符。

Dart 语言版本覆盖注释必须在 '=' 字符后指定版本号，例如 '2.0'。

Dart 语言版本覆盖注释必须使用 '=' 字符指定。

Dart 语言版本覆盖注释必须使用恰好两个斜杠指定。

Dart 语言版本覆盖注释必须使用全部小写的单词 'dart' 指定。

Dart 语言版本覆盖号不能以字母为前缀。

Dart 语言版本覆盖号必须以 '@dart' 开头。

语言版本覆盖不能指定大于最新已知语言版本的版本：{0}.{1}。

必须在任何声明或指令之前指定语言版本覆盖。

说明

#

当看起来像是尝试指定语言版本覆盖的注释不符合此类注释的要求时，分析器会生成此诊断信息。更多信息，请参见 按库选择语言版本 。

示例

#

以下代码会生成此诊断信息，因为在此类注释中，单词 dart 必须是小写的，并且在单词 dart 和版本号之间没有等号：

dart
// @Dart 2.13

常规修复

#

如果注释旨在作为语言版本覆盖，则更改注释以遵循正确的格式：

dart
// @dart = 2.13

invalid_literal_annotation

#

只有 const 构造函数才能具有 @literal 注解。

说明

#

当 literal 注解应用于 const 构造函数以外的任何内容时，分析器会生成此诊断信息。

示例

#

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

dart
import 'package:meta/meta.dart';

class C {
  @literal
  C();
}

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

dart
import 'package:meta/meta.dart';

@literal
var x;

常规修复

#

如果注解位于构造函数上，并且构造函数应该始终使用 const 调用（如果可能），则使用 const 关键字标记构造函数：

dart
import 'package:meta/meta.dart';

class C {
  @literal
  const C();
}

如果构造函数不能标记为 const ，则删除注解。

如果注解位于构造函数以外的任何内容上，则删除注解：

dart
var x;

invalid_modifier_on_constructor

#

修饰符 '{0}' 不能应用于构造函数体。

说明

#

当构造函数体以以下修饰符之一为前缀时，分析器会生成此诊断信息： async 、 async* 或 sync* 。构造函数体必须是同步的。

示例

#

以下代码会生成此诊断信息，因为 C 的构造函数体被标记为 async ：

dart
class C {
  C() async {}
}

常规修复

#

如果构造函数可以是同步的，则删除修饰符：

dart
class C {
  C();
}

如果构造函数不能是同步的，则改用静态方法来创建实例：

dart
class C {
  C();
  static Future<C> c() async {
    return C();
  }
}

invalid_modifier_on_setter

#

setter 不能使用 'async'、'async*' 或 'sync*'。

说明

#

当 setter 的体以以下修饰符之一为前缀时，分析器会生成此诊断信息： async 、 async* 或 sync* 。setter 体必须是同步的。

示例

#

以下代码会生成此诊断信息，因为 setter x 的体被标记为 async ：

dart
class C {
  set x(int i) async {}
}

常规修复

#

如果 setter 可以是同步的，则删除修饰符：

dart
class C {
  set x(int i) {}
}

如果 setter 不能是同步的，则改用方法来设置值：

dart
class C {
  void x(int i) async {}
}

invalid_non_virtual_annotation

#

注解 '@nonVirtual' 只能应用于具体的实例成员。

说明

#

当在类、mixin 或枚举的成员以外的声明中找到 nonVirtual 注解，或者成员不是具体的实例成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为注解位于类声明上，而不是类内的成员上：

dart
import 'package:meta/meta.dart';

@nonVirtual
class C {}

以下代码会生成此诊断信息，因为方法 m 是抽象方法：

dart
import 'package:meta/meta.dart';

abstract class C {
  @nonVirtual
  void m();
}

以下代码会生成此诊断信息，因为方法 m 是静态方法：

dart
import 'package:meta/meta.dart';

abstract class C {
  @nonVirtual
  static void m() {}
}

常规修复

#

如果声明不是类、mixin 或枚举的成员，则删除注解：

dart
class C {}

如果成员旨在成为具体的实例成员，则使其成为：

dart
import 'package:meta/meta.dart';

abstract class C {
  @nonVirtual
  void m() {}
}

如果成员不旨在成为具体的实例成员，则删除注解：

dart
abstract class C {
  static void m() {}
}

invalid_null_aware_operator

#

元素不能为 null，因此空感知运算符 '?' 是不必要的。

映射条目键不能为 null，因此空感知运算符 '?' 是不必要的。

映射条目值不能为 null，因此空感知运算符 '?' 是不必要的。

由于短路，接收者不能为 'null'，因此不能使用空感知运算符 '{0}'。

接收者不能为 null，因此空感知运算符 '{0}' 是不必要的。

说明

#

当在已知为非空的接收者上使用空感知运算符（ ?. 、 ?.. 、 ?[ 、 ?..[ 或 ...? ）时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 s 不能为 null ：

dart
int? getLength(String s) {
  return s?.length;
}

以下代码会生成此诊断信息，因为 a 不能为 null ：

dart
var a = [];
var b = [...?a];

以下代码会生成此诊断信息，因为 s?.length 不能返回 null ：

dart
void f(String? s) {
  s?.length?.isEven;
}

s?.length 不能返回 null 的原因是，如果 s 为 null ，则跟随 s 的空感知运算符会使 length 和 isEven 的计算短路。换句话说，如果 s 为 null ，则不会调用 length 和 isEven ，如果 s 为非 null ，则 length 不能返回 null 值。无论哪种方式， isEven 都不能在 null 值上调用，因此空感知运算符是不必要的。有关更多详细信息，请参见 了解空安全 。

以下代码会生成此诊断信息，因为 s 不能为 null 。

dart
void f(Object? o) {
  var s = o as String;
  s?.length;
}

s 不能为 null 的原因，尽管 o 可以为 null ，是因为强制转换为 String ，它是一种非空类型。如果 o 曾经具有值 null ，则强制转换将失败，并且不会调用 length 。

以下代码会生成此诊断信息，因为 s 不能为 null ：

dart
List<String> makeSingletonList(String s) {
  return <String>[?s];
}

常规修复

#

将空感知运算符替换为非空感知等效项；例如，将 ?. 更改为 . ：

dart
int getLength(String s) {
  return s.length;
}

（请注意，返回类型也已更改为非空，这在某些情况下可能不合适。）

invalid_override

#

' {1}.{0}' ('{2}') 不是 '{3}.{0}' ('{4}') 的有效覆盖。

setter '{1}.{0}' ('{2}') 不是 '{3}.{0}' ('{4}') 的有效覆盖。

说明

#

当找到类的成员覆盖超类型的成员，并且覆盖无效时，分析器会生成此诊断信息。如果满足以下所有条件，则覆盖有效：

  • 它允许被覆盖的成员允许的所有参数。
  • 它不需要被覆盖的成员不需要的任何参数。
  • 被覆盖成员的每个参数的类型都可以赋值给覆盖的相应参数。
  • 覆盖的返回类型可以赋值给被覆盖成员的返回类型。

示例

#

以下代码会生成此诊断信息，因为参数 s 的类型（ String ）无法赋值给参数 i 的类型（ int ）：

dart
class A {
  void m(int i) {}
}

class B extends A {
  void m(String s) {}
}

常规修复

#

如果无效的方法旨在覆盖超类中的方法，则将其更改为符合：

dart
class A {
  void m(int i) {}
}

class B extends A {
  void m(int i) {}
}

如果它不打算覆盖超类中的方法，则将其重命名：

dart
class A {
  void m(int i) {}
}

class B extends A {
  void m2(String s) {}
}

invalid_override_of_non_virtual_member

#

成员 '{0}' 在 '{1}' 中声明为非虚拟的，不能在子类中被覆盖。

说明

#

当类的成员覆盖在其上带有 @nonVirtual 注解的成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 B 中的方法 m 覆盖了 A 中的方法 m ，而 A 中的方法 m 用 @nonVirtual 注解注释：

dart
import 'package:meta/meta.dart';

class A {
  @nonVirtual
  void m() {}
}

class B extends A {
  @override
  void m() {}
}

常规修复

#

如果超类中方法上的注解正确（超类中的方法不打算被覆盖），则删除或重命名覆盖方法：

dart
import 'package:meta/meta.dart';

class A {
  @nonVirtual
  void m() {}
}

class B extends A {}

如果超类中的方法旨在被覆盖，则删除 @nonVirtual 注解：

dart
class A {
  void m() {}
}

class B extends A {
  @override
  void m() {}
}

invalid_pattern_variable_in_shared_case_scope

#

说明

#

当 switch 语句中的多个 case 子句共享一个主体，并且至少一个子句声明一个在共享语句中引用的变量，但该变量不是在所有 case 子句中都声明，或者以不一致的方式声明时，分析器会生成此诊断信息。

如果变量不是在所有 case 子句中都声明的，则如果匹配并执行主体的是未声明变量的子句之一，则它将没有值。这包括其中一个 case 子句是 default 子句的情况。

如果变量以不一致的方式声明，即在某些情况下是 final 而在其他情况下不是 final ，或者在不同的情况下具有不同的类型，则未定义变量的类型或 final 性应是什么的语义。

示例

#

以下代码会生成此诊断信息，因为变量 a 只在一个 case 子句中声明，如果第二个子句是与 x 匹配并执行主体的子句，则它将没有值：

dart
void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    case 0:
      a;
  }
}

以下代码会生成此诊断信息，因为变量 a 在 default 子句中未声明，如果执行主体，则它将没有值，因为没有其他子句与 x 匹配：

dart
void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    default:
      a;
  }
}

以下代码会生成此诊断信息，因为如果执行主体，则变量 a 将没有值，因为不同的 case 组导致控制在标签处继续：

dart
void f(Object? x) {
  switch (x) {
    someLabel:
    case int a when a > 0:
      a;
    case int b when b < 0:
      continue someLabel;
  }
}

以下代码会生成此诊断信息，因为如果执行主体，则变量 a 将没有值，因为不同的 case 组导致控制在标签处继续：

dart
void f(Object? x) {
  switch (x) {
    case int a when a < 0:
    case num a when a > 0:
      a;
  }
}

以下代码会生成此诊断信息，因为变量 a 在第一个 case 子句中是 final ，而在第二个 case 子句中不是 final ：

dart
void f(Object? x) {
  switch (x) {
    case final int a when a < 0:
    case int a when a > 0:
      a;
  }
}

常规修复

#

如果变量不是在所有情况下都声明的，并且您需要在语句中引用它，则在其他情况下声明它：

dart
void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    case int a when a == 0:
      a;
  }
}

如果变量不是在所有情况下都声明的，并且您不需要在语句中引用它，则删除对它的引用并从其他情况下删除声明：

dart
void f(int x) {
  switch (x) {
    case > 0:
    case 0:
  }
}

如果变量的类型不同，则确定变量应具有的类型，并使情况保持一致：

dart
void f(Object? x) {
  switch (x) {
    case num a when a < 0:
    case num a when a > 0:
      a;
  }
}

如果变量的 final 性不同，则决定它应该是 final 还是非 final ，并使情况保持一致：

dart
void f(Object? x) {
  switch (x) {
    case final int a when a < 0:
    case final int a when a > 0:
      a;
  }
}

invalid_platforms_field

#

'platforms' 字段必须是一个以平台为键的映射。

说明

#

当指定顶级 platforms 字段时，但其值不是一个具有键的映射时，分析器会生成此诊断信息。 要了解有关指定包支持的平台的更多信息，请查看 平台声明文档 。

示例

#

以下 pubspec.yaml 会生成此诊断信息，因为 platforms 应为映射。

yaml
name: example
platforms:
  - android
  - web
  - ios

常规修复

#

如果您能够依赖于自动平台检测，则省略顶级 platforms 字段。

yaml
name: example

如果您需要手动指定支持的平台列表，则将 platforms 字段编写为一个以平台名称为键的映射。

yaml
name: example
platforms:
  android:
  web:
  ios:

invalid_reference_to_generative_enum_constructor

#

生成式枚举构造函数只能用作重定向的目标。

说明

#

当在枚举上定义的生成式构造函数用于创建枚举常量以外的任何内容或作为同一枚举中另一个构造函数的重定向目标时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 E 的构造函数在函数 f 中被用来创建实例：

dart
enum E {
  a(0);

  const E(int x);
}

E f() => const E(2) ;

常规修复

#

如果有具有相同值的枚举值，或者如果您添加了这样的常量，则直接引用该常量：

dart
enum E {
  a(0), b(2);

  const E(int x);
}

E f() => E.b;

如果您需要使用构造函数调用，则使用工厂构造函数：

dart
enum E {
  a(0);

  const E(int x);

  factory E.c(int x) => a;
}

E f() => E.c(2);

invalid_reference_to_this

#

对 'this' 表达式的无效引用。

说明

#

当在实例方法或生成式构造函数以外的地方使用 this 时，分析器会生成此诊断信息。保留字 this 仅在实例方法、生成式构造函数或延迟实例字段声明的初始化器的上下文中定义。

示例

#

以下代码会生成此诊断信息，因为 v 是顶级变量：

dart
C f() => this;

class C {}

常规修复

#

使用适当类型的变量代替 this ，如有必要，声明它：

dart
C f(C c) => c;

class C {}

invalid_return_type_for_catch_error

#

类型为 '{0}' 的值不能由 'onError' 处理程序返回，因为它必须可赋值给 '{1}'。

返回类型 '{0}' 无法赋值给 '{1}'，这是 'Future.catchError' 所需的。

说明

#

当 Future.catchError 的调用具有返回类型与 Future 实例返回的类型不兼容的参数时，分析器会生成此诊断信息。在运行时，方法 catchError 尝试将回调中的值作为期货的结果返回，这会导致抛出另一个异常。

示例

#

以下代码会生成此诊断信息，因为 future 声明为返回 int ，而 callback 声明为返回 String ，而 String 不是 int 的子类型：

dart
void f(Future<int> future, String Function(dynamic, StackTrace) callback) {
  future.catchError(callback);
}

以下代码会生成此诊断信息，因为传递给 catchError 的闭包返回 int ，而 future 声明为返回 String ：

dart
void f(Future<String> future) {
  future.catchError((error, stackTrace) => 3);
}

常规修复

#

如果 Future 的实例声明正确，则更改回调以匹配：

dart
void f(Future<int> future, int Function(dynamic, StackTrace) callback) {
  future.catchError(callback);
}

如果 Future 的实例声明错误，则将其更改为与回调匹配：

dart
void f(Future<String> future, String Function(dynamic, StackTrace) callback) {
  future.catchError(callback);
}

invalid_sealed_annotation

#

注解 '@sealed' 只能应用于类。

说明

#

当类声明以外的声明具有 @sealed 注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 @sealed 注解位于方法声明上：

dart
import 'package:meta/meta.dart';

class A {
  @sealed
  void m() {}
}

常规修复

#

删除注解：

dart
class A {
  void m() {}
}

invalid_super_formal_parameter_location

#

超类参数只能在非重定向生成式构造函数中使用。

说明

#

当在非重定向生成式构造函数以外的任何地方使用超类参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为超类参数 x 位于重定向生成式构造函数中：

dart
class A {
  A(int x);
}

class B extends A {
  B.b(super.x) : this._();
  B._() : super(0);
}

以下代码会生成此诊断信息，因为超类参数 x 不在生成式构造函数中：

dart
class A {
  A(int x);
}

class C extends A {
  factory C.c(super.x) => C._();
  C._() : super(0);
}

以下代码会生成此诊断信息，因为超类参数 x 位于方法中：

dart
class A {
  A(int x);
}

class D extends A {
  D() : super(0);

  void m(super.x) {}
}

常规修复

#

如果包含超类参数的函数可以更改为非重定向生成式构造函数，则这样做：

dart
class A {
  A(int x);
}

class B extends A {
  B.b(super.x);
}

如果包含超类参数的函数不能更改为非重定向生成式构造函数，则删除 super ：

dart
class A {
  A(int x);
}

class D extends A {
  D() : super(0);

  void m(int x) {}
}

invalid_type_argument_in_const_literal

#

常量列表字面量不能在类型参数中使用类型参数，例如 '{0}'。

常量映射字面量不能在类型参数中使用类型参数，例如 '{0}'。

常量集合字面量不能在类型参数中使用类型参数，例如 '{0}'。

说明

#

当在以 const 为前缀的列表、映射或集合字面量的类型参数中使用类型参数时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值（运行时将使用的实际类型）在编译时无法知道。

示例

#

以下代码会生成此诊断信息，因为在创建常量列表时，类型参数 T 用作类型参数：

dart
List<T> newList<T>() => const <T>[];

以下代码会生成此诊断信息，因为在创建常量映射时，类型参数 T 用作类型参数：

dart
Map<String, T> newSet<T>() => const <String, T>{};

以下代码会生成此诊断信息，因为在创建常量集合时，类型参数 T 用作类型参数：

dart
Set<T> newSet<T>() => const <T>{};

常规修复

#

如果可以在编译时知道将用于类型参数的类型，则删除类型参数：

dart
List<int> newList() => const <int>[];

如果直到运行时才能知道将用于类型参数的类型，则删除关键字 const ：

dart
List<T> newList<T>() => <T>[];

invalid_uri

#

无效的 URI 语法：'{0}'。

说明

#

当指令中的 URI 不符合有效 URI 的语法时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 '#' 不是有效的 URI：

dart
import '#';

常规修复

#

将无效的 URI 替换为有效的 URI。

invalid_use_of_covariant_in_extension

#

在扩展中不能有修饰符 '{0}'。

说明

#

当扩展中声明的成员在参数的声明中使用关键字 covariant 时，分析器会生成此诊断信息。

说明

#

当扩展不是类并且没有子类时，分析器会生成此诊断信息，因此关键字没有任何作用。

示例

#

以下代码会生成此诊断信息，因为 i 被标记为协变：

dart
extension E on String {
  void a(covariant int i) {}
}

常规修复

#

删除 covariant 关键字：

dart
extension E on String {
  void a(int i) {}
}

invalid_use_of_internal_member

#

成员 '{0}' 只能在其包内使用。

说明

#

当在包含声明的包之外找到对用 internal 注解注释的声明的引用时，分析器会生成此诊断信息。

示例

#

给定一个定义包含用 internal 注解注释的声明的库的包 p ：

dart
import 'package:meta/meta.dart';

@internal
class C {}

以下代码会生成此诊断信息，因为它正在引用类 C ，而 C 不打算在包 p 外使用：

dart
import 'package:p/src/p.dart';

void f(C c) {}

常规修复

#

删除对内部声明的引用。

invalid_use_of_null_value

#

值为 'null' 的表达式的值不能取消引用。

说明

#

当值为 null 的表达式的值被取消引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 将始终为 null ：

dart
int f(Null x) {
  return x.length;
}

常规修复

#

如果允许该值为除 null 以外的其他值，则更改表达式的类型：

dart
int f(String? x) {
  return x!.length;
}

invalid_use_of_type_outside_library

#

类 '{0}' 不能在其库之外扩展，因为它是一个 final 类。

类 '{0}' 不能在其库之外扩展，因为它是一个接口类。

类 '{0}' 不能在其库之外扩展、实现或混合，因为它是一个密封类。

类 '{0}' 不能在其库之外实现，因为它是一个基类。

类 '{0}' 不能在其库之外实现，因为它是一个 final 类。

类 '{0}' 不能在其库之外用作 mixin 超类约束，因为它是一个 final 类。

mixin '{0}' 不能在其库之外实现，因为它是一个基 mixin。

说明

#

当 extends 、 implements 、 with 或 on 子句以不允许的方式使用类或 mixin 时，分析器会生成此诊断信息，该方式根据该类或 mixin 声明上的修饰符而定。

该消息指定了声明的使用方式以及为什么不允许它。

示例

#

给定一个定义基类 A 的文件 a.dart ：

dart
base class A {}

以下代码会生成此诊断信息，因为类 B 实现类 A ，但 base 修饰符阻止 A 在定义它的库之外实现：

dart
import 'a.dart';

final class B implements A {}

常规修复

#

在其声明库之外限制此类型的使用。如果可以使用不同的、不受限制的类型来提供类似的功能，则替换该类型：

dart
class B implements C {}
class C {}

如果没有其他合适的类型，则删除该类型，并可能删除整个子句：

dart
class B {}

invalid_use_of_visible_for_overriding_member

#

成员 '{0}' 只能用于覆盖。

说明

#

当用 visibleForOverriding 注解注释的实例成员在其声明的库之外被引用，且原因不是为了覆盖它时，分析器会生成此诊断信息。

示例

#

给定一个包含以下声明的文件 a.dart ：

dart
import 'package:meta/meta.dart';

class A {
  @visibleForOverriding
  void a() {}
}

以下代码会生成此诊断信息，因为它正在调用方法 m ，即使它公开的唯一原因是允许覆盖它：

dart
import 'a.dart';

class B extends A {
  void b() {
    a() ;
  }
}

常规修复

#

删除对成员的无效使用。

invalid_use_of_visible_for_testing_member

#

成员 '{0}' 只能在 '{1}' 或测试中使用。

说明

#

当用 @visibleForTesting 注释的成员在声明它的库或 test 目录中的库以外的任何地方被引用时，分析器会生成此诊断信息。

示例

#

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

dart
import 'package:meta/meta.dart';

class C {
  @visibleForTesting
  void m() {}
}

以下代码，当不在 test 目录内时，会生成此诊断信息，因为方法 m 被标记为仅对测试可见：

dart
import 'c.dart';

void f(C c) {
  c. m() ;
}

常规修复

#

如果不需要在测试之外引用带注释的成员，则删除引用：

dart
import 'c.dart';

void f(C c) {}

如果可以在测试之外引用带注释的成员，则删除注解：

dart
class C {
  void m() {}
}

invalid_visibility_annotation

#

成员 '{0}' 用 '{1}' 注释，但此注释仅对公共成员的声明有意义。

说明

#

当将 visibleForTemplate 或 visibleForTesting 注解应用于非公共声明时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
import 'package:meta/meta.dart';

@visibleForTesting
void _someFunction() {}

void f() => _someFunction();

常规修复

#

如果不需要测试代码使用该声明，则删除注解：

dart
void _someFunction() {}

void f() => _someFunction();

如果需要使用它，则将其设为公共的：

dart
import 'package:meta/meta.dart';

@visibleForTesting
void someFunction() {}

void f() => someFunction();

invalid_visible_for_overriding_annotation

#

注解 'visibleForOverriding' 只能应用于可以被覆盖的公共实例成员。

说明

#

当类的公共实例成员以外的任何内容用 visibleForOverriding 注解注释时，分析器会生成此诊断信息。因为只有公共实例成员才能在定义库之外被覆盖，所以注释任何其他声明都没有意义。

示例

#

以下代码会生成此诊断信息，因为注解位于类上，而类不能被覆盖：

dart
import 'package:meta/meta.dart';

@visibleForOverriding
class C {}

常规修复

#

删除注解：

dart
class C {}

invalid_visible_outside_template_annotation

#

注解 'visibleOutsideTemplate' 只能应用于用 'visibleForTemplate' 注解注释的类、枚举或 mixin 的成员。

说明

#

当 @visibleOutsideTemplate 注解使用不正确时，分析器会生成此诊断信息。此注解仅用于注释具有 @visibleForTemplate 注解的类、枚举或 mixin 的成员，以使这些成员免受 @visibleForTemplate 强加的可见性限制。

示例

#

以下代码会生成此诊断信息，因为类级别没有 @visibleForTemplate 注解：

dart
import 'package:angular_meta/angular_meta.dart';

class C {
  @visibleOutsideTemplate
  int m() {
    return 1;
  }
}

以下代码会生成此诊断信息，因为注解位于类声明上，而不是类、枚举或 mixin 的成员上：

dart
import 'package:angular_meta/angular_meta.dart';

@visibleOutsideTemplate
class C {}

常规修复

#

如果该类仅可见以便模板可以引用它，则向该类添加 @visibleForTemplate 注解：

dart
import 'package:angular_meta/angular_meta.dart';

@visibleForTemplate
class C {
  @visibleOutsideTemplate
  int m() {
    return 1;
  }
}

如果 @visibleOutsideTemplate 注解不在具有 @visibleForTemplate 注解的类、枚举或 mixin 的成员上，则删除注解：

dart
class C {}

invocation_of_extension_without_call

#

扩展 '{0}' 没有定义 'call' 方法，因此重写不能在调用中使用。

说明

#

当扩展重写用于调用函数，但扩展没有声明 call 方法时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有定义 call 方法：

dart
extension E on String {}

void f() {
  E('')() ;
}

常规修复

#

如果扩展旨在定义 call 方法，则声明它：

dart
extension E on String {
  int call() => 0;
}

void f() {
  E('')();
}

如果扩展类型定义了 call 方法，则删除扩展重写。

如果没有定义 call 方法，则重写代码，使其不调用 call 方法。

invocation_of_non_function

#

' {0}' 不是函数。

说明

#

当找到函数调用，但正在调用的函数的名称被定义为非函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 Binary 是函数类型而不是函数的名称：

dart
typedef Binary = int Function(int, int);

int f() {
  return Binary(1, 2) ;
}

常规修复

#

将名称替换为函数的名称。

invocation_of_non_function_expression

#

表达式不会计算为函数，因此不能调用它。

说明

#

当找到函数调用，但引用的名称不是函数的名称，或者计算函数的表达式没有计算函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 不是函数：

dart
int x = 0;

int f() => x;

var y = x() ;

以下代码会生成此诊断信息，因为 f() 没有返回函数：

dart
int x = 0;

int f() => x;

var y = f()() ;

常规修复

#

如果您需要调用函数，则将参数列表之前的代码替换为函数的名称或计算函数的表达式：

dart
int x = 0;

int f() => x;

var y = f();

label_in_outer_scope

#

无法引用在外部方法中声明的标签 '{0}'。

说明

#

当 break 或 continue 语句引用在包含出现 break 或 continue 语句的函数的方法或函数中声明的标签时，分析器会生成此诊断信息。 break 和 continue 语句不能用于将控制转移到包含它们的函数之外。

示例

#

以下代码会生成此诊断信息，因为标签 loop 在局部函数 g 之外声明：

dart
void f() {
  loop:
  while (true) {
    void g() {
      break loop;
    }

    g();
  }
}

常规修复

#

尝试重写代码，使其不需要将控制转移到局部函数之外，可能通过内联局部函数：

dart
void f() {
  loop:
  while (true) {
    break loop;
  }
}

如果这不可行，则尝试重写局部函数，以便可以使用不同的控制流机制：

函数返回的值可以用来确定是否转移控制：

dart
void f() {
  loop:
  while (true) {
    bool g() {
      return true;
    }

    if (g()) {
      break loop;
    }
  }
}

label_undefined

#

无法引用未定义的标签 '{0}'。

说明

#

当找到对在引用它的 break 或 continue 语句的作用域中未定义的标签的引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标签 loop 在任何地方都没有定义：

dart
void f() {
  for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
      if (j != 0) {
        break loop;
      }
    }
  }
}

常规修复

#

如果标签应该位于最内层的 do 、 for 、 switch 或 while 语句上，则删除该标签：

dart
void f() {
  for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
      if (j != 0) {
        break;
      }
    }
  }
}

如果标签应该位于其他语句上，则添加该标签：

dart
void f() {
  loop: for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
      if (j != 0) {
        break loop;
      }
    }
  }
}

late_final_field_with_const_constructor

#

在具有生成式 const 构造函数的类中，不能有 late final 字段。

说明

#

当至少有一个 const 构造函数的类也具有同时标记为 late 和 final 的字段时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 A 有一个 const 构造函数，并且 final 字段 f 被标记为 late ：

dart
class A {
  late final int f;

  const A();
}

常规修复

#

如果不需要将字段标记为 late ，则从字段中删除 late 修饰符：

dart
class A {
  final int f = 0;

  const A();
}

如果必须将字段标记为 late ，则从构造函数中删除 const 修饰符：

dart
class A {
  late final int f;

  A();
}

late_final_local_already_assigned

#

late final 局部变量已赋值。

说明

#

当分析器可以证明同时标记为 late 和 final 的局部变量在发生另一次赋值时已赋值时，分析器会生成此诊断信息。

因为 final 变量只能赋值一次，所以后续赋值保证会失败，因此它们会被标记。

示例

#

以下代码会生成此诊断信息，因为 final 变量 v 在两个地方被赋值：

dart
int f() {
  late final int v;
  v = 0;
  v += 1;
  return v;
}

常规修复

#

如果您需要能够重新赋值变量，则删除 final 关键字：

dart
int f() {
  late int v;
  v = 0;
  v += 1;
  return v;
}

如果您不需要重新赋值变量，则删除除第一次赋值之外的所有赋值：

dart
int f() {
  late final int v;
  v = 0;
  return v;
}

leaf_call_must_not_return_handle

#

FFI 叶子调用不能返回 'Handle'。

说明

#

当 Pointer.asFunction 或 DynamicLibrary.lookupFunction 的调用中的 isLeaf 参数的值为 true ，并且将返回的函数的返回类型为 Handle 时，分析器会生成此诊断信息。

当 Native 注解中的 isLeaf 参数的值为 true ，并且注解上的类型参数是返回类型为 Handle 的函数类型时，分析器也会生成此诊断信息。

在所有这些情况下，叶子调用仅支持类型 bool 、 int 、 float 、 double ，以及作为返回类型 void 。

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

示例

#

以下代码会生成此诊断信息，因为函数 p 返回 Handle ，但 isLeaf 参数为 true ：

dart
import 'dart:ffi';

void f(Pointer<NativeFunction<Handle Function()>> p) {
  p.asFunction<Object Function()>(isLeaf: true);
}

常规修复

#

如果函数返回句柄，则删除 isLeaf 参数：

dart
import 'dart:ffi';

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

如果函数返回受支持的类型之一，则更正类型信息：

dart
import 'dart:ffi';

void f(Pointer<NativeFunction<Int32 Function()>> p) {
  p.asFunction<int Function()>(isLeaf: true);
}

leaf_call_must_not_take_handle

#

FFI 叶子调用不能接受类型为 'Handle' 的参数。

说明

#

当 Pointer.asFunction 或 DynamicLibrary.lookupFunction 的调用中的 isLeaf 参数的值为 true ，并且将返回的函数的参数类型为 Handle 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为函数 p 的参数类型为 Handle ，但 isLeaf 参数为 true ：

dart
import 'dart:ffi';

void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
  p.asFunction<void Function(Object)>(isLeaf: true);
}

常规修复

#

如果函数至少有一个类型为 Handle 的参数，则删除 isLeaf 参数：

dart
import 'dart:ffi';

void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
  p.asFunction<void Function(Object)>();
}

如果函数的参数都不是 Handle ，则更正类型信息：

dart
import 'dart:ffi';

void f(Pointer<NativeFunction<Void Function(Int8)>> p) {
  p.asFunction<void Function(int)>(isLeaf: true);
}

list_element_type_not_assignable

#

元素类型 '{0}' 无法赋值给列表类型 '{1}'。

说明

#

当列表字面量中元素的类型无法赋值给列表的元素类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 2.5 是双精度浮点数，而列表只能容纳整数：

dart
List<int> x = [1, 2.5, 3];

常规修复

#

如果您打算向列表中添加不同的对象，则用计算所需对象的表达式替换该元素：

dart
List<int> x = [1, 2, 3];

如果该对象不应该在列表中，则删除该元素：

dart
List<int> x = [1, 3];

如果正在计算的对象正确，则加宽列表的元素类型以允许它需要包含的所有不同类型的对象：

dart
List<num> x = [1, 2.5, 3];

main_first_positional_parameter_type

#

'main' 函数的第一个位置参数的类型必须是 'List' 的超类型。

说明

#

当名为 main 的函数的第一个位置参数不是 List<String> 的超类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 List<int> 不是 List<String> 的超类型：

dart
void main(List<int> args) {}

常规修复

#

如果该函数是入口点，则将第一个位置参数的类型更改为 List<String> 的超类型：

dart
void main(List<String> args) {}

如果该函数不是入口点，则更改函数的名称：

dart
void f(List<int> args) {}

main_has_required_named_parameters

#

'main' 函数不能有任何必需的命名参数。

说明

#

当名为 main 的函数具有一个或多个必需的命名参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名为 main 的函数有一个必需的命名参数（ x ）：

dart
void main({required int x}) {}

常规修复

#

如果该函数是入口点，则删除 required 关键字：

dart
void main({int? x}) {}

如果该函数不是入口点，则更改函数的名称：

dart
void f({required int x}) {}

main_has_too_many_required_positional_parameters

#

'main' 函数不能有多于两个必需的位置参数。

说明

#

当名为 main 的函数具有多于两个必需的位置参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 main 具有三个必需的位置参数：

dart
void main(List<String> args, int x, int y) {}

常规修复

#

如果该函数是入口点并且未使用的额外参数，则将其删除：

dart
void main(List<String> args, int x) {}

如果该函数是入口点，但使用的额外参数是当该函数不用作入口点时使用的参数，则使额外参数成为可选的：

dart
void main(List<String> args, int x, [int y = 0]) {}

如果该函数不是入口点，则更改函数的名称：

dart
void f(List<String> args, int x, int y) {}

main_is_not_function

#

名为 'main' 的声明必须是函数。

说明

#

当库包含名为 main 的声明，但它不是顶级函数的声明时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 main 用于声明顶级变量：

dart
var main = 3;

常规修复

#

对声明使用不同的名称：

dart
var mainIndex = 3;

map_entry_not_in_map

#

映射条目只能在映射字面量中使用。

说明

#

当在集合字面量中找到映射条目（键/值对）时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字面量有映射条目，即使它是集合字面量：

dart
var collection = <String>{'a' : 'b'};

常规修复

#

如果您希望集合为映射，则更改代码使其成为映射。在上一个示例中，您可以通过添加另一个类型参数来实现：

dart
var collection = <String, String>{'a' : 'b'};

在其他情况下，您可能需要将显式类型从 Set 更改为 Map 。

如果您希望集合为集合，则删除映射条目，如果集合中应包含两个值，则可能通过将冒号替换为逗号来实现：

dart
var collection = <String>{'a', 'b'};

map_key_type_not_assignable

#

元素类型 '{0}' 无法赋值给映射键类型 '{1}'。

说明

#

当映射字面量中键值对的键的类型无法赋值给映射的键类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 2 是 int ，但映射的键需要是 String ：

dart
var m = <String, String>{2 : 'a'};

常规修复

#

如果映射的类型正确，则更改键使其具有正确的类型：

dart
var m = <String, String>{'2' : 'a'};

如果键的类型正确，则更改映射的键类型：

dart
var m = <int, String>{2 : 'a'};

map_value_type_not_assignable

#

元素类型 '{0}' 无法赋值给映射值类型 '{1}'。

说明

#

当映射字面量中键值对的值的类型无法赋值给映射的值类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 2 是 int ，但映射的值需要是 String ：

dart
var m = <String, String>{'a' : 2};

常规修复

#

如果映射的类型正确，则更改值使其具有正确的类型：

dart
var m = <String, String>{'a' : '2'};

如果值的类型正确，则更改映射的值类型：

说明

#

当 switch 语句中的多个 case 子句共享一个主体，并且至少一个子句声明一个在共享语句中引用的变量，但该变量不是在所有 case 子句中都声明，或者以不一致的方式声明时，分析器会生成此诊断信息。

如果变量不是在所有 case 子句中都声明的，则如果匹配并执行主体的是未声明变量的子句之一，则它将没有值。这包括其中一个 case 子句是 default 子句的情况。

如果变量以不一致的方式声明，即在某些情况下是 final 而在其他情况下不是 final ，或者在不同的情况下具有不同的类型，则未定义变量的类型或 final 性应是什么的语义。

示例

#

以下代码会生成此诊断信息，因为变量 a 只在一个 case 子句中声明，如果第二个子句是与 x 匹配并执行主体的子句，则它将没有值：

dart
void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    case 0:
      a;
  }
}

以下代码会生成此诊断信息，因为变量 a 在 default 子句中未声明，如果执行主体，则它将没有值，因为没有其他子句与 x 匹配：

dart
void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    default:
      a;
  }
}

以下代码会生成此诊断信息，因为如果执行主体，则变量 a 将没有值，因为不同的 case 组导致控制在标签处继续：

dart
void f(Object? x) {
  switch (x) {
    someLabel:
    case int a when a > 0:
      a;
    case int b when b < 0:
      continue someLabel;
  }
}

以下代码会生成此诊断信息，因为变量 a 在所有 case 子句中都被赋值，但在每个子句中与它关联的类型并不相同：

dart
void f(Object? x) {
  switch (x) {
    case int a when a < 0:
    case num a when a > 0:
      a;
  }
}

以下代码会生成此诊断信息，因为变量 a 在第一个 case 子句中是 final ，而在第二个 case 子句中不是 final ：

dart
void f(Object? x) {
  switch (x) {
    case final int a when a < 0:
    case int a when a > 0:
      a;
  }
}

常规修复

#

如果变量不是在所有情况下都声明的，并且您需要在语句中引用它，则在其他情况下声明它：

dart
void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    case int a when a == 0:
      a;
  }
}

如果变量不是在所有情况下都声明的，并且您不需要在语句中引用它，则删除对它的引用并从其他情况下删除声明：

dart
void f(int x) {
  switch (x) {
    case > 0:
    case 0:
  }
}

如果变量的类型不同，则确定变量应具有的类型，并使情况保持一致：

dart
void f(Object? x) {
  switch (x) {
    case num a when a < 0:
    case num a when a > 0:
      a;
  }
}

如果变量的 final 性不同，则决定它应该是 final 还是非 final ，并使情况保持一致：

dart
void f(Object? x) {
  switch (x) {
    case final int a when a < 0:
    case final int a when a > 0:
      a;
  }
}

invalid_platforms_field

#

'platforms' 字段必须是一个以平台为键的映射。

说明

#

当指定顶级 platforms 字段时，但其值不是一个具有键的映射时，分析器会生成此诊断信息。 要了解有关指定包支持的平台的更多信息，请查看 平台声明文档 。

示例

#

以下 pubspec.yaml 会生成此诊断信息，因为 platforms 应为映射。

yaml
name: example
platforms:
  - android
  - web
  - ios

常规修复

#

如果您能够依赖于自动平台检测，则省略顶级 platforms 字段。

yaml
name: example

如果您需要手动指定支持的平台列表，则将 platforms 字段编写为一个以平台名称为键的映射。

yaml
name: example
platforms:
  android:
  web:
  ios:

invalid_reference_to_generative_enum_constructor

#

生成式枚举构造函数只能用作重定向的目标。

说明

#

当在枚举上定义的生成式构造函数用于创建枚举常量以外的任何内容或作为同一枚举中另一个构造函数的重定向目标时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 E 的构造函数在函数 f 中被用来创建实例：

dart
enum E {
  a(0);

  const E(int x);
}

E f() => const E(2) ;

常规修复

#

如果有具有相同值的枚举值，或者如果您添加了这样的常量，则直接引用该常量：

dart
enum E {
  a(0), b(2);

  const E(int x);
}

E f() => E.b;

如果您需要使用构造函数调用，则使用工厂构造函数：

dart
enum E {
  a(0);

  const E(int x);

  factory E.c(int x) => a;
}

E f() => E.c(2);

invalid_reference_to_this

#

对 'this' 表达式的无效引用。

说明

#

当在实例方法或生成式构造函数以外的地方使用 this 时，分析器会生成此诊断信息。保留字 this 仅在实例方法、生成式构造函数或延迟实例字段声明的初始化器的上下文中定义。

示例

#

以下代码会生成此诊断信息，因为 v 是顶级变量：

dart
C f() => this;

class C {}

常规修复

#

使用适当类型的变量代替 this ，如有必要，声明它：

dart
C f(C c) => c;

class C {}

invalid_return_type_for_catch_error

#

类型为 '{0}' 的值不能由 'onError' 处理程序返回，因为它必须可赋值给 '{1}'。

返回类型 '{0}' 无法赋值给 '{1}'，这是 'Future.catchError' 所需的。

说明

#

当 Future.catchError 的调用具有返回类型与 Future 实例返回的类型不兼容的参数时，分析器会生成此诊断信息。在运行时，方法 catchError 尝试将回调中的值作为期货的结果返回，这会导致抛出另一个异常。

示例

#

以下代码会生成此诊断信息，因为 future 声明为返回 int ，而 callback 声明为返回 String ，而 String 不是 int 的子类型：

dart
void f(Future<int> future, String Function(dynamic, StackTrace) callback) {
  future.catchError(callback);
}

以下代码会生成此诊断信息，因为传递给 catchError 的闭包返回 int ，而 future 声明为返回 String ：

dart
void f(Future<String> future) {
  future.catchError((error, stackTrace) => 3);
}

常规修复

#

如果 Future 的实例声明正确，则更改回调以匹配：

dart
void f(Future<int> future, int Function(dynamic, StackTrace) callback) {
  future.catchError(callback);
}

如果 Future 的实例声明错误，则将其更改为与回调匹配：

dart
void f(Future<String> future, String Function(dynamic, StackTrace) callback) {
  future.catchError(callback);
}

invalid_sealed_annotation

#

注解 '@sealed' 只能应用于类。

说明

#

当类声明以外的声明具有 @sealed 注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 @sealed 注解位于方法声明上：

dart
import 'package:meta/meta.dart';

class A {
  @sealed
  void m() {}
}

常规修复

#

删除注解：

dart
class A {
  void m() {}
}

invalid_super_formal_parameter_location

#

超类参数只能在非重定向生成式构造函数中使用。

说明

#

当在非重定向生成式构造函数以外的任何地方使用超类参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为超类参数 x 位于重定向生成式构造函数中：

dart
class A {
  A(int x);
}

class B extends A {
  B.b(super.x) : this._();
  B._() : super(0);
}

以下代码会生成此诊断信息，因为超类参数 x 不在生成式构造函数中：

dart
class A {
  A(int x);
}

class C extends A {
  factory C.c(super.x) => C._();
  C._() : super(0);
}

以下代码会生成此诊断信息，因为超类参数 x 位于方法中：

dart
class A {
  A(int x);
}

class D extends A {
  D() : super(0);

  void m(super.x) {}
}

常规修复

#

如果包含超类参数的函数可以更改为非重定向生成式构造函数，则这样做：

dart
class A {
  A(int x);
}

class B extends A {
  B.b(super.x);
}

如果包含超类参数的函数不能更改为非重定向生成式构造函数，则删除 super ：

dart
class A {
  A(int x);
}

class D extends A {
  D() : super(0);

  void m(int x) {}
}

invalid_type_argument_in_const_literal

#

常量列表字面量不能在类型参数中使用类型参数，例如 '{0}'。

常量映射字面量不能在类型参数中使用类型参数，例如 '{0}'。

常量集合字面量不能在类型参数中使用类型参数，例如 '{0}'。

说明

#

当在以 const 为前缀的列表、映射或集合字面量的类型参数中使用类型参数时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值（运行时将使用的实际类型）在编译时无法知道。

示例

#

以下代码会生成此诊断信息，因为在创建常量列表时，类型参数 T 用作类型参数：

dart
List<T> newList<T>() => const <T>[];

以下代码会生成此诊断信息，因为在创建常量映射时，类型参数 T 用作类型参数：

dart
Map<String, T> newSet<T>() => const <String, T>{};

以下代码会生成此诊断信息，因为在创建常量集合时，类型参数 T 用作类型参数：

dart
Set<T> newSet<T>() => const <T>{};

常规修复

#

如果可以在编译时知道将用于类型参数的类型，则删除类型参数：

dart
List<int> newList() => const <int>[];

如果直到运行时才能知道将用于类型参数的类型，则删除关键字 const ：

dart
List<T> newList<T>() => <T>[];

invalid_uri

#

无效的 URI 语法：'{0}'。

说明

#

当指令中的 URI 不符合有效 URI 的语法时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 '#' 不是有效的 URI：

dart
import '#';

常规修复

#

将无效的 URI 替换为有效的 URI。

invalid_use_of_covariant_in_extension

#

扩展中不能有修饰符 '{0}'。

说明

#

当扩展中声明的成员在参数的声明中使用关键字 covariant 时，分析器会生成此诊断信息。扩展不是类，也没有子类，因此关键字没有任何作用。

示例

#

以下代码会生成此诊断信息，因为 i 被标记为协变：

dart
extension E on String {
  void a(covariant int i) {}
}

常规修复

#

删除 covariant 关键字：

dart
extension E on String {
  void a(int i) {}
}

invalid_use_of_internal_member

#

成员 '{0}' 只能在其包内使用。

说明

#

当在包含声明的包之外找到对用 internal 注解注释的声明的引用时，分析器会生成此诊断信息。

示例

#

给定一个定义包含用 internal 注解注释的声明的库的包 p ：

dart
import 'package:meta/meta.dart';

@internal
class C {}

以下代码会生成此诊断信息，因为它正在引用类 C ，而 C 不打算在包 p 外使用：

dart
import 'package:p/src/p.dart';

void f(C c) {}

常规修复

#

删除对内部声明的引用。

invalid_use_of_null_value

#

值为 'null' 的表达式的值不能取消引用。

说明

#

当值为 null 的表达式的值被取消引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 将始终为 null ：

dart
int f(Null x) {
  return x.length;
}

常规修复

#

如果允许该值为除 null 以外的其他值，则更改表达式的类型：

dart
int f(String? x) {
  return x!.length;
}

invalid_use_of_type_outside_library

#

类 '{0}' 不能在其库之外扩展，因为它是一个 final 类。

类 '{0}' 不能在其库之外扩展，因为它是一个接口类。

类 '{0}' 不能在其库之外扩展、实现或混合，因为它是一个密封类。

类 '{0}' 不能在其库之外实现，因为它是一个基类。

类 '{0}' 不能在其库之外实现，因为它是一个 final 类。

类 '{0}' 不能在其库之外用作 mixin 超类约束，因为它是一个 final 类。

mixin '{0}' 不能在其库之外实现，因为它是一个基 mixin。

说明

#

当 extends 、 implements 、 with 或 on 子句以不允许的方式使用类或 mixin 时，分析器会生成此诊断信息，该方式根据该类或 mixin 声明上的修饰符而定。

该消息指定了声明的使用方式以及为什么不允许它。

示例

#

给定一个定义基类 A 的文件 a.dart ：

dart
base class A {}

以下代码会生成此诊断信息，因为类 B 实现类 A ，但 base 修饰符阻止 A 在定义它的库之外实现：

dart
import 'a.dart';

final class B implements A {}

常规修复

#

在其声明库之外限制此类型的使用。如果可以使用不同的、不受限制的类型来提供类似的功能，则替换该类型：

dart
class B implements C {}
class C {}

如果没有其他合适的类型，则删除该类型，并可能删除整个子句：

dart
class B {}

invalid_use_of_visible_for_overriding_member

#

成员 '{0}' 只能用于覆盖。

说明

#

当用 visibleForOverriding 注解注释的实例成员在其声明的库之外被引用，且原因不是为了覆盖它时，分析器会生成此诊断信息。

示例

#

给定一个包含以下声明的文件 a.dart ：

dart
import 'package:meta/meta.dart';

class A {
  @visibleForOverriding
  void a() {}
}

以下代码会生成此诊断信息，因为它正在调用方法 m ，即使它公开的唯一原因是允许覆盖它：

dart
import 'a.dart';

class B extends A {
  void b() {
    a() ;
  }
}

常规修复

#

删除对成员的无效使用。

invalid_use_of_visible_for_testing_member

#

成员 '{0}' 只能在 '{1}' 或测试中使用。

说明

#

当用 @visibleForTesting 注释的成员在声明它的库或 test 目录中的库以外的任何地方被引用时，分析器会生成此诊断信息。

示例

#

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

dart
import 'package:meta/meta.dart';

class C {
  @visibleForTesting
  void m() {}
}

以下代码，当不在 test 目录内时，会生成此诊断信息，因为方法 m 被标记为仅对测试可见：

dart
import 'c.dart';

void f(C c) {
  c. m() ;
}

常规修复

#

如果不需要在测试之外引用带注释的成员，则删除引用：

dart
import 'c.dart';

void f(C c) {}

如果可以在测试之外引用带注释的成员，则删除注解：

dart
class C {
  void m() {}
}

invalid_visibility_annotation

#

成员 '{0}' 用 '{1}' 注释，但此注释仅对公共成员的声明有意义。

说明

#

当将 visibleForTemplate 或 visibleForTesting 注解应用于非公共声明时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
import 'package:meta/meta.dart';

@visibleForTesting
void _someFunction() {}

void f() => _someFunction();

常规修复

#

如果不需要测试代码使用该声明，则删除注解：

dart
void _someFunction() {}

void f() => _someFunction();

如果需要使用它，则将其设为公共的：

dart
import 'package:meta/meta.dart';

@visibleForTesting
void someFunction() {}

void f() => someFunction();

invalid_visible_for_overriding_annotation

#

注解 'visibleForOverriding' 只能应用于可以被覆盖的公共实例成员。

说明

#

当类的公共实例成员以外的任何内容用 visibleForOverriding 注解注释时，分析器会生成此诊断信息。因为只有公共实例成员才能在定义库之外被覆盖，所以注释任何其他声明都没有意义。

示例

#

以下代码会生成此诊断信息，因为注解位于类上，而类不能被覆盖：

dart
import 'package:meta/meta.dart';

@visibleForOverriding
class C {}

常规修复

#

删除注解：

dart
class C {}

invalid_visible_outside_template_annotation

#

注解 'visibleOutsideTemplate' 只能应用于用 'visibleForTemplate' 注解注释的类、枚举或 mixin 的成员。

说明

#

当 @visibleOutsideTemplate 注解使用不正确时，分析器会生成此诊断信息。此注解仅用于注释具有 @visibleForTemplate 注解的类、枚举或 mixin 的成员，以使这些成员免受 @visibleForTemplate 强加的可见性限制。

示例

#

以下代码会生成此诊断信息，因为类级别没有 @visibleForTemplate 注解：

dart
import 'package:angular_meta/angular_meta.dart';

class C {
  @visibleOutsideTemplate
  int m() {
    return 1;
  }
}

以下代码会生成此诊断信息，因为注解位于类声明上，而不是类、枚举或 mixin 的成员上：

dart
import 'package:angular_meta/angular_meta.dart';

@visibleOutsideTemplate
class C {}

常规修复

#

如果该类仅可见以便模板可以引用它，则向该类添加 @visibleForTemplate 注解：

dart
import 'package:angular_meta/angular_meta.dart';

@visibleForTemplate
class C {
  @visibleOutsideTemplate
  int m() {
    return 1;
  }
}

如果 @visibleOutsideTemplate 注解不在具有 @visibleForTemplate 注解的类、枚举或 mixin 的成员上，则删除注解：

dart
class C {}

invocation_of_extension_without_call

#

扩展 '{0}' 没有定义 'call' 方法，因此重写不能在调用中使用。

说明

#

当扩展重写用于调用函数，但扩展没有声明 call 方法时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有定义 call 方法：

dart
extension E on String {}

void f() {
  E('')() ;
}

常规修复

#

如果扩展旨在定义 call 方法，则声明它：

dart
extension E on String {
  int call() => 0;
}

void f() {
  E('')();
}

如果扩展类型定义了 call 方法，则删除扩展重写。

如果没有定义 call 方法，则重写代码，使其不调用 call 方法。

invocation_of_non_function

#

' {0}' 不是函数。

说明

#

当找到函数调用，但正在调用的函数的名称被定义为非函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 Binary 是函数类型而不是函数的名称：

dart
typedef Binary = int Function(int, int);

int f() {
  return Binary(1, 2) ;
}

常规修复

#

将名称替换为函数的名称。

invocation_of_non_function_expression

#

表达式不会计算为函数，因此不能调用它。

说明

#

当找到函数调用，但引用的名称不是函数的名称，或者计算函数的表达式没有计算函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 不是函数：

dart
int x = 0;

int f() => x;

var y = x() ;

以下代码会生成此诊断信息，因为 f() 没有返回函数：

dart
int x = 0;

int f() => x;

var y = f()() ;

常规修复

#

如果您需要调用函数，则将参数列表之前的代码替换为函数的名称或计算函数的表达式：

dart
int x = 0;

int f() => x;

var y = f();

label_in_outer_scope

#

无法引用在外部方法中声明的标签 '{0}'。

说明

#

当 break 或 continue 语句引用在包含出现 break 或 continue 语句的函数的方法或函数中声明的标签时，分析器会生成此诊断信息。 break 和 continue 语句不能用于将控制转移到包含它们的函数之外。

示例

#

以下代码会生成此诊断信息，因为标签 loop 在局部函数 g 之外声明：

dart
void f() {
  loop:
  while (true) {
    void g() {
      break loop;
    }

    g();
  }
}

常规修复

#

尝试重写代码，使其不需要将控制转移到局部函数之外，可能通过内联局部函数：

dart
void f() {
  loop:
  while (true) {
    break loop;
  }
}

如果这不可行，则尝试重写局部函数，以便可以使用不同的控制流机制：

常规修复

#

添加一个 return 语句，使返回值显式，即使 null 是合适的值。

missing_size_annotation_carray

#

'Array' 类型的字段必须恰好有一个 'Array' 注解。

说明

#

当 Struct 或 Union 的子类中的字段的类型为 Array ，但没有单个 Array 注解指示数组的维度时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 没有 Array 注解：

dart
import 'dart:ffi';

final class C extends Struct {
  external Array<Uint8> a0;
}

常规修复

#

确保字段上恰好有一个 Array 注解：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

missing_variable_pattern

#

此逻辑或模式的分支中缺少变量模式 '{0}'。

说明

#

当逻辑或模式的一个分支没有声明在同一模式的其他分支上声明的变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为逻辑或模式的右侧没有声明变量 a ：

dart
void f((int, int) r) {
  if (r case (var a, 0) || (0, _)) {
    print(a);
  }
}

常规修复

#

如果需要在受控语句中引用该变量，则向逻辑或模式的每个分支添加变量的声明：

dart
void f((int, int) r) {
  if (r case (var a, 0) || (0, var a)) {
    print(a);
  }
}

如果不需要在受控语句中引用该变量，则从逻辑或模式的每个分支中删除变量的声明：

dart
void f((int, int) r) {
  if (r case (_, 0) || (0, _)) {
    print('found a zero');
  }
}

如果在模式的一个分支匹配但另一个分支不匹配时需要引用该变量，则将模式分解成两部分：

dart
void f((int, int) r) {
  switch (r) {
    case (var a, 0):
      print(a);
    case (0, _):
      print('found a zero');
  }
}

mixin_application_concrete_super_invoked_member_type

#

超类调用的成员 '{0}' 的类型为 '{1}'，而类中的具体成员的类型为 '{2}'。

说明

#

当使用 super 调用方法的 mixin 用于类的具体实现与 mixin 的 on 类型为该方法定义的签名不同的类时，分析器会生成此诊断信息。这是错误的原因是，mixin 中的调用可能会以与实际将执行的方法不兼容的方式调用该方法。

示例

#

以下代码会生成此诊断信息，因为类 C 使用 mixin M ，mixin M 使用 super 调用 foo ，而 I （mixin 的 on 类型）中声明的 foo 的抽象版本与 A 中声明的 foo 的具体版本的签名不同：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]);
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B with M {}

常规修复

#

如果类不需要使用 mixin，则将其从 with 子句中删除：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int? p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]);
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B {}

如果类需要使用 mixin，则确保存在符合 mixin 预期签名的具体方法实现：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int? p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]) {
    super.foo(p);
  }
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B with M {}

mixin_application_not_implemented_interface

#

' {0}' 不能混合到 '{1}' 上，因为 '{1}' 没有实现 '{2}'。

说明

#

当具有超类约束的 mixin 用于 mixin 应用 ，而超类没有实现所需约束时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 要求应用它的类是 A 的子类，但 Object 不是 A 的子类：

dart
class A {}

mixin M on A {}

class X = Object with M;

常规修复

#

如果您需要使用 mixin，则将超类更改为与超类约束相同或其子类：

dart
class A {}

mixin M on A {}

class X = A with M;

mixin_application_no_concrete_super_invoked_member

#

该类没有超类调用的成员 '{0}' 的具体实现。

该类没有超类调用的 setter '{0}' 的具体实现。

说明

#

当 mixin 应用 包含从其超类调用成员的调用，并且 mixin 应用的超类中没有该名称的具体成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 包含调用 super.m() ，而类 A （它是 mixin 应用 A+M 的超类）没有定义 m 的具体实现：

dart
abstract class A {
  void m();
}

mixin M on A {
  void bar() {
    super.m();
  }
}

abstract class B extends A with M {}

常规修复

#

如果您打算将 mixin M 应用于不同的类（具有 m 的具体实现的类），则将 B 的超类更改为该类：

dart
abstract class A {
  void m();
}

mixin M on A {
  void bar() {
    super.m();
  }
}

class C implements A {
  void m() {}
}

abstract class B extends C with M {}

如果您需要使 B 成为 A 的子类，则在 A 中添加 m 的具体实现：

dart
abstract class A {
  void m() {}
}

mixin M on A {
  void bar() {
    super.m();
  }
}

abstract class B extends A with M {}

mixin_class_declaration_extends_not_object

#

类 '{0}' 不能声明为 mixin，因为它扩展了除 'Object' 之外的类。

说明

#

当标记有 mixin 修饰符的类扩展了除 Object 之外的类时，分析器会生成此诊断信息。mixin 类不能有除 Object 之外的超类。

示例

#

以下代码会生成此诊断信息，因为具有修饰符 mixin 的类 B 扩展了 A ：

dart
class A {}

mixin class B extends A {}

常规修复

#

如果您希望将该类用作 mixin，则将超类更改为 Object ，方法是显式更改或删除 extends 子句：

dart
class A {}

mixin class B {}

如果该类需要具有除 Object 之外的超类，则删除 mixin 修饰符：

dart
class A {}

class B extends A {}

如果您需要 mixin 和除 Object 之外的类的子类，则将子类的成员移到一个新的 mixin，从子类中删除 mixin 修饰符，并将新的 mixin 应用于子类：

dart
class A {}

class B extends A with M {}

mixin M {}

根据子类的成员，这可能需要向 mixin 添加 on 子句。

mixin_class_declares_constructor

#

类 '{0}' 不能用作 mixin，因为它声明了一个构造函数。

说明

#

当类用作 mixin，并且混合的类定义了一个构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为定义了构造函数的类 A 用作 mixin：

dart
//@dart=2.19
class A {
  A();
}

class B with A {}

常规修复

#

如果可以将类转换为 mixin，则这样做：

dart
mixin A {
}

class B with A {}

如果该类不能是 mixin，并且可以删除构造函数，则这样做：

dart
//@dart=2.19
class A {
}

class B with A {}

如果该类不能是 mixin，并且您无法删除构造函数，则尝试扩展或实现该类，而不是混合它：

dart
class A {
  A();
}

class B extends A {}

mixin_inherits_from_not_object

#

类 '{0}' 不能用作 mixin，因为它扩展了除 'Object' 之外的类。

说明

#

当扩展了除 Object 之外的类的类用作 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展了 A 的类 B 被 C 用作 mixin：

dart
//@dart=2.19
class A {}

class B extends A {}

class C with B {}

常规修复

#

如果用作 mixin 的类可以更改为扩展 Object ，则更改它：

dart
//@dart=2.19
class A {}

class B {}

class C with B {}

如果用作 mixin 的类不能更改，并且使用它的类扩展了 Object ，则扩展用作 mixin 的类：

dart
class A {}

class B extends A {}

class C extends B {}

如果该类没有扩展 Object ，或者如果您想能够在其他地方混合来自 B 的行为，则创建一个真正的 mixin：

dart
class A {}

mixin M on A {}

class B extends A with M {}

class C extends A with M {}

mixin_instantiate

#

不能实例化 mixin。

说明

#

当实例化 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 正在被实例化：

dart
mixin M {}

var m = M() ;

常规修复

#

如果您打算使用类的实例，则使用该类的名称代替 mixin 的名称。

mixin_of_non_class

#

类只能混合 mixin 和类。

说明

#

当 with 子句中的名称被定义为非 mixin 或类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 被定义为函数类型：

dart
typedef F = int Function(String);

class C with F {}

常规修复

#

从列表中删除无效名称，并可能将其替换为预期的 mixin 或类的名称：

dart
typedef F = int Function(String);

class C {}

mixin_on_sealed_class

#

类 '{0}' 不应用作 mixin 约束，因为它已密封，并且任何混合此 mixin 的类都必须具有 '{0}' 作为超类。

说明

#

当 mixin 的超类约束是来自不同包且被标记为 sealed 的类时，分析器会生成此诊断信息。密封类不能扩展、实现、混合或用作超类约束。

示例

#

如果包 p 定义了一个密封类：

dart
import 'package:meta/meta.dart';

@sealed
class C {}

那么，以下代码（在除 p 之外的包中）会生成此诊断信息：

dart
import 'package:p/p.dart';

mixin M on C {}

常规修复

#

如果使用 mixin 的类不需要是密封类的子类，则考虑添加一个字段并委托给密封类的包装实例。

mixin_super_class_constraint_deferred_class

#

延迟加载类不能用作超类约束。

说明

#

常规修复

#

添加一个 return 语句，使返回值显式，即使 null 是合适的值。

missing_size_annotation_carray

#

'Array' 类型的字段必须恰好有一个 'Array' 注解。

说明

#

当 Struct 或 Union 的子类中的字段的类型为 Array ，但没有单个 Array 注解指示数组的维度时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 没有 Array 注解：

dart
import 'dart:ffi';

final class C extends Struct {
  external Array<Uint8> a0;
}

常规修复

#

确保字段上恰好有一个 Array 注解：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

missing_variable_pattern

#

逻辑或模式的此分支中缺少变量模式 '{0}'。

说明

#

当逻辑或模式的一个分支没有声明在同一模式的其他分支上声明的变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为逻辑或模式的右侧没有声明变量 a ：

dart
void f((int, int) r) {
  if (r case (var a, 0) || (0, _)) {
    print(a);
  }
}

常规修复

#

如果需要在受控语句中引用该变量，则向逻辑或模式的每个分支添加变量的声明：

dart
void f((int, int) r) {
  if (r case (var a, 0) || (0, var a)) {
    print(a);
  }
}

如果不需要在受控语句中引用该变量，则从逻辑或模式的每个分支中删除变量的声明：

dart
void f((int, int) r) {
  if (r case (_, 0) || (0, _)) {
    print('found a zero');
  }
}

如果在模式的一个分支匹配但另一个分支不匹配时需要引用该变量，则将模式分解成两部分：

dart
void f((int, int) r) {
  switch (r) {
    case (var a, 0):
      print(a);
    case (0, _):
      print('found a zero');
  }
}

mixin_application_concrete_super_invoked_member_type

#

超类调用的成员 '{0}' 的类型为 '{1}'，而类中的具体成员的类型为 '{2}'。

说明

#

当使用 super 调用方法的 mixin 用于类的具体实现与 mixin 的 on 类型为该方法定义的签名不同的类时，分析器会生成此诊断信息。这是错误的原因是，mixin 中的调用可能会以与实际将执行的方法不兼容的方式调用该方法。

示例

#

以下代码会生成此诊断信息，因为类 C 使用 mixin M ，mixin M 使用 super 调用 foo ，而 I （mixin 的 on 类型）中声明的 foo 的抽象版本与 A 中声明的 foo 的具体版本的签名不同：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]);
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B with M {}

常规修复

#

如果类不需要使用 mixin，则将其从 with 子句中删除：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int? p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]);
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B {}

如果类需要使用 mixin，则确保存在符合 mixin 预期签名的具体方法实现：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int? p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]) {
    super.foo(p);
  }
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B with M {}

mixin_application_not_implemented_interface

#

' {0}' 不能混合到 '{1}' 上，因为 '{1}' 没有实现 '{2}'。

说明

#

当具有超类约束的 mixin 用于 mixin 应用 ，而超类没有实现所需约束时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 要求应用它的类是 A 的子类，但 Object 不是 A 的子类：

dart
class A {}

mixin M on A {}

class X = Object with M;

常规修复

#

如果您需要使用 mixin，则将超类更改为与超类约束相同或其子类：

dart
class A {}

mixin M on A {}

class X = A with M;

mixin_application_no_concrete_super_invoked_member

#

该类没有超类调用的成员 '{0}' 的具体实现。

该类没有超类调用的 setter '{0}' 的具体实现。

说明

#

当 mixin 应用 包含从其超类调用成员的调用，并且 mixin 应用的超类中没有该名称的具体成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 包含调用 super.m() ，而类 A （它是 mixin 应用 A+M 的超类）没有定义 m 的具体实现：

dart
abstract class A {
  void m();
}

mixin M on A {
  void bar() {
    super.m();
  }
}

abstract class B extends A with M {}

常规修复

#

如果您打算将 mixin M 应用于不同的类（具有 m 的具体实现的类），则将 B 的超类更改为该类：

dart
abstract class A {
  void m();
}

mixin M on A {
  void bar() {
    super.m();
  }
}

class C implements A {
  void m() {}
}

abstract class B extends C with M {}

如果您需要使 B 成为 A 的子类，则在 A 中添加 m 的具体实现：

dart
abstract class A {
  void m() {}
}

mixin M on A {
  void bar() {
    super.m();
  }
}

abstract class B extends A with M {}

mixin_class_declaration_extends_not_object

#

类 '{0}' 不能声明为 mixin，因为它扩展了除 'Object' 之外的类。

说明

#

当标记有 mixin 修饰符的类扩展了除 Object 之外的类时，分析器会生成此诊断信息。mixin 类不能有除 Object 之外的超类。

示例

#

以下代码会生成此诊断信息，因为具有修饰符 mixin 的类 B 扩展了 A ：

dart
class A {}

mixin class B extends A {}

常规修复

#

如果您希望将该类用作 mixin，则将超类更改为 Object ，方法是显式更改或删除 extends 子句：

dart
class A {}

mixin class B {}

如果该类需要具有除 Object 之外的超类，则删除 mixin 修饰符：

dart
class A {}

class B extends A {}

如果您需要 mixin 和除 Object 之外的类的子类，则将子类的成员移到一个新的 mixin，从子类中删除 mixin 修饰符，并将新的 mixin 应用于子类：

dart
class A {}

class B extends A with M {}

mixin M {}

根据子类的成员，这可能需要向 mixin 添加 on 子句。

mixin_class_declares_constructor

#

类 '{0}' 不能用作 mixin，因为它声明了一个构造函数。

说明

#

当类用作 mixin，并且混合的类定义了一个构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为定义了构造函数的类 A 用作 mixin：

dart
//@dart=2.19
class A {
  A();
}

class B with A {}

常规修复

#

如果可以将类转换为 mixin，则这样做：

dart
mixin A {
}

class B with A {}

如果该类不能是 mixin，并且可以删除构造函数，则这样做：

dart
//@dart=2.19
class A {
}

class B with A {}

如果该类不能是 mixin，并且您无法删除构造函数，则尝试扩展或实现该类，而不是混合它：

dart
class A {
  A();
}

class B extends A {}

mixin_inherits_from_not_object

#

类 '{0}' 不能用作 mixin，因为它扩展了除 'Object' 之外的类。

说明

#

当扩展了除 Object 之外的类的类用作 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展了 A 的类 B 被 C 用作 mixin：

dart
//@dart=2.19
class A {}

class B extends A {}

class C with B {}

常规修复

#

如果用作 mixin 的类可以更改为扩展 Object ，则更改它：

dart
//@dart=2.19
class A {}

class B {}

class C with B {}

如果用作 mixin 的类不能更改，并且使用它的类扩展了 Object ，则扩展用作 mixin 的类：

dart
class A {}

class B extends A {}

class C extends B {}

如果该类没有扩展 Object ，或者如果您想能够在其他地方混合来自 B 的行为，则创建一个真正的 mixin：

dart
class A {}

mixin M on A {}

class B extends A with M {}

class C extends A with M {}

mixin_instantiate

#

不能实例化 mixin。

说明

#

当实例化 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 正在被实例化：

dart
mixin M {}

var m = M() ;

常规修复

#

如果您打算使用类的实例，则使用该类的名称代替 mixin 的名称。

mixin_of_non_class

#

类只能混合 mixin 和类。

说明

#

当 with 子句中的名称被定义为非 mixin 或类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 被定义为函数类型：

dart
typedef F = void Function();

class C with F {}

常规修复

#

从列表中删除无效名称，并可能将其替换为预期的 mixin 或类的名称：

dart
typedef F = void Function();

class C {}

mixin_on_sealed_class

#

类 '{0}' 不应用作 mixin 约束，因为它已密封，并且任何混合此 mixin 的类都必须具有 '{0}' 作为超类。

说明

#

当 mixin 的超类约束是来自不同包且被标记为 sealed 的类时，分析器会生成此诊断信息。密封类不能扩展、实现、混合或用作超类约束。

示例

#

如果包 p 定义了一个密封类：

dart
import 'package:meta/meta.dart';

@sealed
class C {}

那么，以下代码（在除 p 之外的包中）会生成此诊断信息：

dart
import 'package:p/p.dart';

mixin M on C {}

常规修复

#

如果使用 mixin 的类不需要是密封类的子类，则考虑添加一个字段并委托给密封类的包装实例。

mixin_super_class_constraint_deferred_class

#

延迟加载类不能用作超类约束。

说明

#

当 mixin 的超类约束从延迟加载库导入时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 math.Random 的超类约束是从延迟加载库导入的：

dart
import 'dart:async' deferred as async;

mixin M<T> on async.Stream<T> {}

常规修复

#

如果不需要延迟导入，则删除 deferred 关键字：

dart
import 'dart:async' as async;

mixin M<T> on async.Stream<T> {}

如果需要延迟导入，则删除超类约束：

dart
mixin M<T> {}

mixin_super_class_constraint_non_interface

#

只有类和 mixin 可以用作超类约束。

说明

#

当 mixin 声明中 on 关键字后的类型既不是类也不是 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 既不是类也不是 mixin：

dart
typedef F = void Function();

mixin M on F {}

常规修复

#

如果该类型旨在为类但类型错误，则替换该名称。

否则，从 on 子句中删除该类型。

multiple_redirecting_constructor_invocations

#

构造函数最多只能有一个 'this' 重定向。

说明

#

当构造函数重定向到同一类中的多个其他构造函数（使用 this ）时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 中的未命名构造函数重定向到 this.a 和 this.b ：

dart
class C {
  C() : this.a(), this.b();
  C.a();
  C.b();
}

常规修复

#

删除除一个重定向之外的所有重定向：

dart
class C {
  C() : this.a();
  C.a();
  C.b();
}

multiple_super_initializers

#

构造函数最多只能有一个 'super' 初始化器。

说明

#

当构造函数的初始化器列表包含多个从超类调用构造函数的调用时，分析器会生成此诊断信息。初始化器列表需要恰好有一个这样的调用，它可以是显式的或隐式的。

示例

#

以下代码会生成此诊断信息，因为 B 的构造函数的初始化器列表同时调用了超类 A 中的构造函数 one 和构造函数 two ：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
}

class B extends A {
  B() : super.one(0), super.two('');
}

常规修复

#

如果其中一个超类构造函数将完全初始化实例，则删除另一个：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
}

class B extends A {
  B() : super.one(0);
}

如果其中一个超类构造函数实现的初始化可以在构造函数的主体中执行，则删除其超类调用并在主体中执行初始化：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
}

class B extends A {
  B() : super.one(0) {
    s = '';
  }
}

如果初始化只能在超类中的构造函数中执行，则添加新的构造函数或修改现有构造函数之一，以便有一个构造函数允许在单个调用中执行所有必需的初始化：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
  A.three(this.x, this.s);
}

class B extends A {
  B() : super.three(0, '');
}

must_be_a_native_function_type

#

提供给 '{1}' 的类型 '{0}' 必须是有效的 'dart:ffi' 本机函数类型。

说明

#

当 Pointer.fromFunction 、 DynamicLibrary.lookupFunction 或 NativeCallable 构造函数的调用具有（显式或隐式）类型参数，该参数不是本机函数类型时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为类型 T 可以是 Function 的任何子类，但 fromFunction 的类型参数需要是本机函数类型：

dart
import 'dart:ffi';

int f(int i) => i * 2;

class C<T extends Function> {
  void g() {
    Pointer.fromFunction<T>(f, 0);
  }
}

常规修复

#

使用本机函数类型作为调用的类型参数：

dart
import 'dart:ffi';

int f(int i) => i * 2;

class C<T extends Function> {
  void g() {
    Pointer.fromFunction<Int32 Function(Int32)>(f, 0);
  }
}

must_be_a_subtype

#

类型 '{0}' 必须是 '{1}' 的子类型，用于 '{2}'。

说明

#

分析器在两种情况下会生成此诊断信息：

  • 在 Pointer.fromFunction 或 NativeCallable 构造函数的调用中，类型参数（无论是显式还是隐式）都不是作为第一个参数传递给方法的函数类型的超类型。
  • 在 DynamicLibrary.lookupFunction 的调用中，第一个类型参数不是第二个类型参数的超类型。

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

示例

#

以下代码会生成此诊断信息，因为函数 f 的类型（ String Function(int) ）不是类型参数 T （ Int8 Function(Int8) ）的子类型：

dart
import 'dart:ffi';

typedef T = Int8 Function(Int8);

double f(double i) => i;

void g() {
  Pointer.fromFunction<T>(f, 5.0);
}

常规修复

#

如果该函数正确，则更改类型参数以匹配：

dart
import 'dart:ffi';

typedef T = Float Function(Float);

double f(double i) => i;

void g() {
  Pointer.fromFunction<T>(f, 5.0);
}

如果类型参数正确，则更改函数以匹配：

dart
import 'dart:ffi';

typedef T = Int8 Function(Int8);

int f(int i) => i;

void g() {
  Pointer.fromFunction<T>(f, 5);
}

must_be_immutable

#

此类（或此类继承的类）被标记为 '@immutable'，但其一个或多个实例字段不是 final 的：{0}

说明

#

当不可变类定义了一个或多个不是 final 的实例字段时，分析器会生成此诊断信息。如果类使用注解 immutable 标记为不可变的，或者它是不可变类的子类，则该类是不可变的。

示例

#

以下代码会生成此诊断信息，因为字段 x 不是 final：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  int x;

  C(this.x);
}

常规修复

#

如果类的实例应该是不可变的，则向所有非 final 字段声明添加关键字 final ：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final int x;

  C(this.x);
}

如果类的实例应该是可变的，则删除注解，或者如果继承了注解，则选择不同的超类：

dart
class C {
  int x;

  C(this.x);
}

must_call_super

#

此方法覆盖了在 '{0}' 中用 '@mustCallSuper' 注释的方法，但没有调用被覆盖的方法。

说明

#

当覆盖用 mustCallSuper 注解注释的方法的方法没有按要求调用被覆盖的方法时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 B 中的方法 m 没有调用 A 中被覆盖的方法 m ：

dart
import 'package:meta/meta.dart';

class A {
  @mustCallSuper
  m() {}
}

class B extends A {
  @override
  m() {}
}

常规修复

#

在覆盖方法中添加对被覆盖方法的调用：

dart
import 'package:meta/meta.dart';

class A {
  @mustCallSuper
  m() {}
}

class B extends A {
  @override
  m() {
    super.m();
  }
}

must_return_void

#

传递给 'NativeCallable.listener' 的函数的返回类型必须是 'void' 而不是 '{0}'。

说明

#

当您将不返回 void 的函数传递给 NativeCallable.listener 构造函数时，分析器会生成此诊断信息。

NativeCallable.listener 创建一个可以从任何线程调用的本机可调用对象。调用可调用对象的本机代码会向创建可调用对象的隔离区发送消息，并且不会等待响应。因此，无法从可调用对象返回结果。

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

示例

#

以下代码会生成此诊断信息，因为函数 f 返回 int 而不是 void 。

dart
import 'dart:ffi';

int f(int i) => i * 2;

void g() {
  NativeCallable<Int32 Function(Int32)>.listener(f);
}

常规修复

#

将函数的返回类型更改为 void 。

dart
import 'dart:ffi';

void f(int i) => print(i * 2);

void g() {
  NativeCallable<Void Function(Int32)>.listener(f);
}

name_not_string

#

'name' 字段的值必须是字符串。

说明

#

当顶级 name 键的值不是字符串时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 name 键后面的值是列表：

yaml
name:
  - example

常规修复

#

将值替换为字符串：

yaml
name: example

native_field_invalid_type

#

' {0}' 是本机字段不支持的类型。本机字段仅支持指针、数组或数字和复合类型。

说明

#

当用 @Native 注释的字段的类型不是本机字段支持的类型时，分析器会生成此诊断信息。

本机字段支持指针、数组、数字类型和 Compound 的子类型（即结构体或联合）。其他 NativeType 的子类型，例如 Handle 或 NativeFunction ，不允许作为本机字段。

本机函数应与外部函数一起使用，而不是外部字段。

句柄不受支持，因为无法将 Dart 对象透明地加载和存储到指针中。

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

示例

#

以下代码会生成此诊断信息，因为字段 free 使用不受支持的本机类型 NativeFunction ：

dart
import 'dart:ffi';

@Native<NativeFunction<Void Function()>>()
external void Function() free;

常规修复

#

如果您打算使用 NativeFunction 字段绑定到现有的本机函数，则改用 @Native 方法：

dart
import 'dart:ffi';

@Native<Void Function(Pointer<Void>)>()
external void free(Pointer<Void> ptr);

要绑定到在 C 中存储函数指针的字段，请对 Dart 字段使用指针类型：

dart
import 'dart:ffi';

@Native()
external Pointer<NativeFunction<Void Function(Pointer<Void>)>> free;

native_field_missing_type

#

无法推断此字段的本机类型，必须在注解中指定。

说明

#

当用 @Native 注释的字段需要注解上的类型提示才能推断本机类型时，分析器会生成此诊断信息。

像 int 和 double 这样的 Dart 类型具有多种可能的本机表示形式。由于在访问字段时需要在编译时知道本机类型才能生成正确的加载和存储，因此必须提供显式类型。

示例

#

以下代码会生成此诊断信息，因为字段 f 的类型为 int （它有多种本机表示形式），但在 Native 注解上没有显式类型参数：

dart
import 'dart:ffi';

@Native()
external int f;

常规修复

#

要修复此诊断信息，请从字段的本机声明中找出正确的本机表示形式。然后，将相应的类型添加到 Native 注解的类型参数中：

常规修复

#

添加一个 return 语句，使返回值显式，即使 null 是合适的值。

missing_size_annotation_carray

#

'Array' 类型的字段必须恰好有一个 'Array' 注解。

说明

#

当 Struct 或 Union 的子类中的字段类型为 Array ，但没有单个 Array 注解指示数组的维度时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 没有 Array 注解：

dart
import 'dart:ffi';

final class C extends Struct {
  external Array<Uint8> a0;
}

常规修复

#

确保字段上恰好有一个 Array 注解：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

missing_variable_pattern

#

逻辑或模式的此分支中缺少变量模式 '{0}'。

说明

#

当逻辑或模式的一个分支没有声明在同一模式的其他分支上声明的变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为逻辑或模式的右侧没有声明变量 a ：

dart
void f((int, int) r) {
  if (r case (var a, 0) || (0, _)) {
    print(a);
  }
}

常规修复

#

如果需要在受控语句中引用该变量，则向逻辑或模式的每个分支添加变量的声明：

dart
void f((int, int) r) {
  if (r case (var a, 0) || (0, var a)) {
    print(a);
  }
}

如果不需要在受控语句中引用该变量，则从逻辑或模式的每个分支中删除变量的声明：

dart
void f((int, int) r) {
  if (r case (_, 0) || (0, _)) {
    print('found a zero');
  }
}

如果在模式的一个分支匹配但另一个分支不匹配时需要引用该变量，则将模式分解成两部分：

dart
void f((int, int) r) {
  switch (r) {
    case (var a, 0):
      print(a);
    case (0, _):
      print('found a zero');
  }
}

mixin_application_concrete_super_invoked_member_type

#

超类调用的成员 '{0}' 的类型为 '{1}'，而类中的具体成员的类型为 '{2}'。

说明

#

当使用 super 调用方法的 mixin 用于类的具体实现与 mixin 的 on 类型为该方法定义的签名不同的类时，分析器会生成此诊断信息。这是错误的原因是，mixin 中的调用可能会以与实际将执行的方法不兼容的方式调用该方法。

示例

#

以下代码会生成此诊断信息，因为类 C 使用 mixin M ，mixin M 使用 super 调用 foo ，而 I （mixin 的 on 类型）中声明的 foo 的抽象版本与 A 中声明的 foo 的具体版本的签名不同：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]);
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B with M {}

常规修复

#

如果类不需要使用 mixin，则将其从 with 子句中删除：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int? p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]);
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B {}

如果类需要使用 mixin，则确保存在符合 mixin 预期签名的具体方法实现：

dart
class I {
  void foo([int? p]) {}
}

class A {
  void foo(int? p) {}
}

abstract class B extends A implements I {
  @override
  void foo([int? p]) {
    super.foo(p);
  }
}

mixin M on I {
  void bar() {
    super.foo(42);
  }
}

abstract class C extends B with M {}

mixin_application_not_implemented_interface

#

' {0}' 不能混合到 '{1}' 上，因为 '{1}' 没有实现 '{2}'。

说明

#

当具有超类约束的 mixin 用于 mixin 应用 ，而超类没有实现所需约束时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 要求应用它的类是 A 的子类，但 Object 不是 A 的子类：

dart
class A {}

mixin M on A {}

class X = Object with M;

常规修复

#

如果您需要使用 mixin，则将超类更改为与超类约束相同或其子类：

dart
class A {}

mixin M on A {}

class X = A with M;

mixin_application_no_concrete_super_invoked_member

#

该类没有超类调用的成员 '{0}' 的具体实现。

该类没有超类调用的 setter '{0}' 的具体实现。

说明

#

当 mixin 应用 包含从其超类调用成员的调用，并且 mixin 应用的超类中没有该名称的具体成员时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 包含调用 super.m() ，而类 A （它是 mixin 应用 A+M 的超类）没有定义 m 的具体实现：

dart
abstract class A {
  void m();
}

mixin M on A {
  void bar() {
    super.m();
  }
}

abstract class B extends A with M {}

常规修复

#

如果您打算将 mixin M 应用于不同的类（具有 m 的具体实现的类），则将 B 的超类更改为该类：

dart
abstract class A {
  void m();
}

mixin M on A {
  void bar() {
    super.m();
  }
}

class C implements A {
  void m() {}
}

abstract class B extends C with M {}

如果您需要使 B 成为 A 的子类，则在 A 中添加 m 的具体实现：

dart
abstract class A {
  void m() {}
}

mixin M on A {
  void bar() {
    super.m();
  }
}

abstract class B extends A with M {}

mixin_class_declaration_extends_not_object

#

类 '{0}' 不能声明为 mixin，因为它扩展了除 'Object' 之外的类。

说明

#

当标记有 mixin 修饰符的类扩展了除 Object 之外的类时，分析器会生成此诊断信息。mixin 类不能有除 Object 之外的超类。

示例

#

以下代码会生成此诊断信息，因为具有修饰符 mixin 的类 B 扩展了 A ：

dart
class A {}

mixin class B extends A {}

常规修复

#

如果您希望将该类用作 mixin，则将超类更改为 Object ，方法是显式更改或删除 extends 子句：

dart
class A {}

mixin class B {}

如果该类需要具有除 Object 之外的超类，则删除 mixin 修饰符：

dart
class A {}

class B extends A {}

如果您需要 mixin 和除 Object 之外的类的子类，则将子类的成员移到一个新的 mixin，从子类中删除 mixin 修饰符，并将新的 mixin 应用于子类：

dart
class A {}

class B extends A with M {}

mixin M {}

根据子类的成员，这可能需要向 mixin 添加 on 子句。

mixin_class_declares_constructor

#

类 '{0}' 不能用作 mixin，因为它声明了一个构造函数。

说明

#

当类用作 mixin，并且混合的类定义了一个构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为定义了构造函数的类 A 用作 mixin：

dart
//@dart=2.19
class A {
  A();
}

class B with A {}

常规修复

#

如果可以将类转换为 mixin，则这样做：

dart
mixin A {
}

class B with A {}

如果该类不能是 mixin，并且可以删除构造函数，则这样做：

dart
//@dart=2.19
class A {
}

class B with A {}

如果该类不能是 mixin，并且您无法删除构造函数，则尝试扩展或实现该类，而不是混合它：

dart
class A {
  A();
}

class B extends A {}

mixin_inherits_from_not_object

#

类 '{0}' 不能用作 mixin，因为它扩展了除 'Object' 之外的类。

说明

#

当扩展了除 Object 之外的类的类用作 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展了 A 的类 B 被 C 用作 mixin：

dart
//@dart=2.19
class A {}

class B extends A {}

class C with B {}

常规修复

#

如果用作 mixin 的类可以更改为扩展 Object ，则更改它：

dart
//@dart=2.19
class A {}

class B {}

class C with B {}

如果用作 mixin 的类不能更改，并且使用它的类扩展了 Object ，则扩展用作 mixin 的类：

dart
class A {}

class B extends A {}

class C extends B {}

如果该类没有扩展 Object ，或者如果您想能够在其他地方混合来自 B 的行为，则创建一个真正的 mixin：

dart
class A {}

mixin M on A {}

class B extends A with M {}

class C extends A with M {}

mixin_instantiate

#

不能实例化 mixin。

说明

#

当实例化 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 mixin M 正在被实例化：

dart
mixin M {}

var m = M() ;

常规修复

#

如果您打算使用类的实例，则使用该类的名称代替 mixin 的名称。

mixin_of_non_class

#

类只能混合 mixin 和类。

说明

#

当 with 子句中的名称被定义为非 mixin 或类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 被定义为函数类型：

dart
typedef F = void Function();

class C with F {}

常规修复

#

从列表中删除无效名称，并可能将其替换为预期的 mixin 或类的名称：

dart
typedef F = void Function();

class C {}

mixin_on_sealed_class

#

类 '{0}' 不应用作 mixin 约束，因为它已密封，并且任何混合此 mixin 的类都必须具有 '{0}' 作为超类。

说明

#

当 mixin 的超类约束是来自不同包且被标记为 sealed 的类时，分析器会生成此诊断信息。密封类不能扩展、实现、混合或用作超类约束。

示例

#

如果包 p 定义了一个密封类：

dart
import 'package:meta/meta.dart';

@sealed
class C {}

那么，以下代码（在除 p 之外的包中）会生成此诊断信息：

dart
import 'package:p/p.dart';

mixin M on C {}

常规修复

#

如果使用 mixin 的类不需要是密封类的子类，则考虑添加一个字段并委托给密封类的包装实例。

mixin_super_class_constraint_deferred_class

#

延迟加载类不能用作超类约束。

说明

#

当 mixin 的超类约束从延迟加载库导入时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 math.Random 的超类约束是从延迟加载库导入的：

dart
import 'dart:async' deferred as async;

mixin M<T> on async.Stream<T> {}

常规修复

#

如果不需要延迟导入，则删除 deferred 关键字：

dart
import 'dart:async' as async;

mixin M<T> on async.Stream<T> {}

如果需要延迟导入，则删除超类约束：

dart
mixin M<T> {}

mixin_super_class_constraint_non_interface

#

只有类和 mixin 可以用作超类约束。

说明

#

当 mixin 声明中 on 关键字后的类型既不是类也不是 mixin 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 既不是类也不是 mixin：

dart
typedef F = void Function();

mixin M on F {}

常规修复

#

如果该类型旨在为类但类型错误，则替换该名称。

否则，从 on 子句中删除该类型。

multiple_redirecting_constructor_invocations

#

构造函数最多只能有一个 'this' 重定向。

说明

#

当构造函数重定向到同一类中的多个其他构造函数（使用 this ）时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 中的未命名构造函数重定向到 this.a 和 this.b ：

dart
class C {
  C() : this.a(), this.b();
  C.a();
  C.b();
}

常规修复

#

删除除一个重定向之外的所有重定向：

dart
class C {
  C() : this.a();
  C.a();
  C.b();
}

multiple_super_initializers

#

构造函数最多只能有一个 'super' 初始化器。

说明

#

当构造函数的初始化器列表包含多个从超类调用构造函数的调用时，分析器会生成此诊断信息。初始化器列表需要恰好有一个这样的调用，它可以是显式的或隐式的。

示例

#

以下代码会生成此诊断信息，因为 B 的构造函数的初始化器列表同时调用了超类 A 中的构造函数 one 和构造函数 two ：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
}

class B extends A {
  B() : super.one(0), super.two('');
}

常规修复

#

如果其中一个超类构造函数将完全初始化实例，则删除另一个：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
}

class B extends A {
  B() : super.one(0);
}

如果其中一个超类构造函数实现的初始化可以在构造函数的主体中执行，则删除其超类调用并在主体中执行初始化：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
}

class B extends A {
  B() : super.one(0) {
    s = '';
  }
}

如果初始化只能在超类中的构造函数中执行，则添加新的构造函数或修改现有构造函数之一，以便有一个构造函数允许在单个调用中执行所有必需的初始化：

dart
class A {
  int? x;
  String? s;
  A.one(this.x);
  A.two(this.s);
  A.three(this.x, this.s);
}

class B extends A {
  B() : super.three(0, '');
}

must_be_a_native_function_type

#

提供给 '{1}' 的类型 '{0}' 必须是有效的 'dart:ffi' 本机函数类型。

说明

#

当 Pointer.fromFunction 、 DynamicLibrary.lookupFunction 或 NativeCallable 构造函数的调用具有（显式或隐式）类型参数，该参数不是本机函数类型时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为类型 T 可以是 Function 的任何子类，但 fromFunction 的类型参数需要是本机函数类型：

dart
import 'dart:ffi';

int f(int i) => i * 2;

class C<T extends Function> {
  void g() {
    Pointer.fromFunction<T>(f, 0);
  }
}

常规修复

#

使用本机函数类型作为调用的类型参数：

dart
import 'dart:ffi';

int f(int i) => i * 2;

class C<T extends Function> {
  void g() {
    Pointer.fromFunction<Int32 Function(Int32)>(f, 0);
  }
}

must_be_a_subtype

#

类型 '{0}' 必须是 '{1}' 的子类型，用于 '{2}'。

说明

#

分析器在两种情况下会生成此诊断信息：

  • 在 Pointer.fromFunction 或 NativeCallable 构造函数的调用中，类型参数（无论是显式还是隐式）都不是作为第一个参数传递给方法的函数类型的超类型。
  • 在 DynamicLibrary.lookupFunction 的调用中，第一个类型参数不是第二个类型参数的超类型。

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

示例

#

以下代码会生成此诊断信息，因为函数 f 的类型（ String Function(int) ）不是类型参数 T （ Int8 Function(Int8) ）的子类型：

dart
import 'dart:ffi';

typedef T = Int8 Function(Int8);

double f(double i) => i;

void g() {
  Pointer.fromFunction<T>(f, 5.0);
}

常规修复

#

如果该函数正确，则更改类型参数以匹配：

dart
import 'dart:ffi';

typedef T = Float Function(Float);

double f(double i) => i;

void g() {
  Pointer.fromFunction<T>(f, 5.0);
}

如果类型参数正确，则更改函数以匹配：

dart
import 'dart:ffi';

typedef T = Int8 Function(Int8);

int f(int i) => i;

void g() {
  Pointer.fromFunction<T>(f, 5);
}

must_be_immutable

#

此类（或此类继承的类）被标记为 '@immutable'，但其一个或多个实例字段不是 final 的：{0}

说明

#

当不可变类定义了一个或多个不是 final 的实例字段时，分析器会生成此诊断信息。如果类使用注解 immutable 标记为不可变的，或者它是不可变类的子类，则该类是不可变的。

示例

#

以下代码会生成此诊断信息，因为字段 x 不是 final：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  int x;

  C(this.x);
}

常规修复

#

如果类的实例应该是不可变的，则向所有非 final 字段声明添加关键字 final ：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final int x;

  C(this.x);
}

如果类的实例应该是可变的，则删除注解，或者如果继承了注解，则选择不同的超类：

dart
class C {
  int x;

  C(this.x);
}

must_call_super

#

此方法覆盖了在 '{0}' 中用 '@mustCallSuper' 注释的方法，但没有调用被覆盖的方法。

说明

#

当覆盖用 mustCallSuper 注解注释的方法的方法没有按要求调用被覆盖的方法时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 B 中的方法 m 没有调用 A 中被覆盖的方法 m ：

dart
import 'package:meta/meta.dart';

class A {
  @mustCallSuper
  m() {}
}

class B extends A {
  @override
  m() {}
}

常规修复

#

在覆盖方法中添加对被覆盖方法的调用：

dart
import 'package:meta/meta.dart';

class A {
  @mustCallSuper
  m() {}
}

class B extends A {
  @override
  m() {
    super.m();
  }
}

must_return_void

#

传递给 'NativeCallable.listener' 的函数的返回类型必须是 'void' 而不是 '{0}'。

说明

#

当您将不返回 void 的函数传递给 NativeCallable.listener 构造函数时，分析器会生成此诊断信息。

NativeCallable.listener 创建一个可以从任何线程调用的本机可调用对象。调用可调用对象的本机代码会向创建可调用对象的隔离区发送消息，并且不会等待响应。因此，无法从可调用对象返回结果。

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

示例

#

以下代码会生成此诊断信息，因为函数 f 返回 int 而不是 void 。

dart
import 'dart:ffi';

int f(int i) => i * 2;

void g() {
  NativeCallable<Int32 Function(Int32)>.listener(f);
}

常规修复

#

将函数的返回类型更改为 void 。

dart
import 'dart:ffi';

void f(int i) => print(i * 2);

void g() {
  NativeCallable<Void Function(Int32)>.listener(f);
}

name_not_string

#

'name' 字段的值必须是字符串。

说明

#

当顶级 name 键的值不是字符串时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 name 键后面的值是列表：

yaml
name:
  - example

常规修复

#

将值替换为字符串：

yaml
name: example

native_field_invalid_type

#

' {0}' 是本机字段不支持的类型。本机字段仅支持指针、数组或数字和复合类型。

说明

#

当用 @Native 注释的字段的类型不是本机字段支持的类型时，分析器会生成此诊断信息。

本机字段支持指针、数组、数字类型和 Compound 的子类型（即结构体或联合）。其他 NativeType 的子类型，例如 Handle 或 NativeFunction ，不允许作为本机字段。

本机函数应与外部函数一起使用，而不是外部字段。

句柄不受支持，因为无法将 Dart 对象透明地加载和存储到指针中。

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

示例

#

以下代码会生成此诊断信息，因为字段 free 使用不受支持的本机类型 NativeFunction ：

dart
import 'dart:ffi';

@Native<NativeFunction<Void Function()>>()
external void Function() free;

常规修复

#

如果您打算使用 NativeFunction 字段绑定到现有的本机函数，则改用 @Native 方法：

dart
import 'dart:ffi';

@Native<Void Function(Pointer<Void>)>()
external void free(Pointer<Void> ptr);

要绑定到在 C 中存储函数指针的字段，请对 Dart 字段使用指针类型：

dart
import 'dart:ffi';

@Native()
external Pointer<NativeFunction<Void Function(Pointer<Void>)>> free;

native_field_missing_type

#

无法推断此字段的本机类型，必须在注解中指定。

说明

#

当用 @Native 注释的字段需要注解上的类型提示才能推断本机类型时，分析器会生成此诊断信息。

Dart 类型如 int 和 double 具有多种可能的本机表示形式。由于在访问字段时需要在编译时知道本机类型才能生成正确的加载和存储，因此必须提供显式类型。

示例

#

以下代码会生成此诊断信息，因为字段 f 的类型为 int （它有多种本机表示形式），但在 Native 注解上没有显式类型参数：

dart
import 'dart:ffi';

@Native()
external int f;

常规修复

#

要修复此诊断信息，请从字段的本机声明中找出正确的本机表示形式。然后，将相应的类型添加到 Native 注解的类型参数中：

例如，如果 f 在 C 中声明为 uint8_t ，则应将 Dart 字段声明为：

dart
import 'dart:ffi';

@Native<Uint8>()
external int f;

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

native_field_not_static

#

本机字段必须是静态的。

说明

#

当类的实例字段用 @Native 注释时，分析器会生成此诊断信息。 本机字段引用 C、C++ 或其他本机语言中的全局变量，而 Dart 中的实例字段特定于该类的实例。因此，本机字段必须是静态的。

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

示例

#

以下代码会生成此诊断信息，因为类 C 中的字段 f 是 @Native ，但不是 static ：

dart
import 'dart:ffi';

class C {
  @Native<Int>()
  external int f;
}

常规修复

#

使字段成为静态的：

dart
import 'dart:ffi';

class C {
  @Native<Int>()
  external static int f;
}

或者将其移出类，在这种情况下不需要显式的 static 修饰符：

dart
import 'dart:ffi';

class C {
}

@Native<Int>()
external int f;

如果您打算注释应作为结构体一部分的实例字段，请省略 @Native 注解：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int()
  external int f;
}

new_with_undefined_constructor_default

#

类 '{0}' 没有未命名的构造函数。

说明

#

当在定义了命名构造函数但类没有未命名构造函数的类上调用未命名构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 没有定义未命名的构造函数：

dart
class A {
  A.a();
}

A f() => A() ;

常规修复

#

如果命名构造函数之一执行您所需的操作，则使用它：

dart
class A {
  A.a();
}

A f() => A.a();

如果命名构造函数都不执行您所需的操作，并且您可以添加未命名的构造函数，则添加该构造函数：

dart
class A {
  A();
  A.a();
}

A f() => A();

non_abstract_class_inherits_abstract_member

#

缺少 '{0}' 的具体实现。

缺少 '{0}' 和 '{1}' 的具体实现。

缺少 '{0}'、'{1}'、'{2}'、'{3}' 和其他 {4} 个具体实现。

缺少 '{0}'、'{1}'、'{2}' 和 '{3}' 的具体实现。

缺少 '{0}'、'{1}' 和 '{2}' 的具体实现。

说明

#

当具体类继承一个或多个抽象成员，并且没有为至少一个抽象成员提供或继承实现时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 B 没有 m 的具体实现：

dart
abstract class A {
  void m();
}

class B extends A {}

常规修复

#

如果子类可以为一些或所有抽象继承成员提供具体实现，则添加具体实现：

dart
abstract class A {
  void m();
}

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

如果存在提供继承方法实现的 mixin，则将 mixin 应用于子类：

dart
abstract class A {
  void m();
}

class B extends A with M {}

mixin M {
  void m() {}
}

如果子类无法为所有抽象继承成员提供具体实现，则将子类标记为抽象：

dart
abstract class A {
  void m();
}

abstract class B extends A {}

non_bool_condition

#

条件必须具有 'bool' 的静态类型。

说明

#

当 if 或 while 循环等条件不具有静态类型 bool 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 的静态类型为 int ：

dart
void f(int x) {
  if (x) {
    // ...
  }
}

常规修复

#

更改条件，使其产生布尔值：

dart
void f(int x) {
  if (x == 0) {
    // ...
  }
}

non_bool_expression

#

断言中的表达式必须是 'bool' 类型。

说明

#

当断言中的第一个表达式的类型不是 bool 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 p 的类型为 int ，但需要 bool ：

dart
void f(int p) {
  assert(p);
}

常规修复

#

更改表达式，使其类型为 bool ：

dart
void f(int p) {
  assert(p > 0);
}

non_bool_negation_expression

#

否定操作数必须具有 'bool' 的静态类型。

说明

#

当一元否定运算符 (!) 的操作数的类型不是 bool 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 是 int ，而它必须是 bool ：

dart
int x = 0;
bool y = !x;

常规修复

#

将操作数替换为具有类型 bool 的表达式：

dart
int x = 0;
bool y = !(x > 0);

non_bool_operand

#

运算符 '{0}' 的操作数必须可赋值为 'bool'。

说明

#

当 && 或 || 运算符的操作数之一的类型不是 bool 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 a 不是布尔值：

dart
int a = 3;
bool b = a || a > 1;

常规修复

#

将操作数更改为布尔值：

dart
int a = 3;
bool b = a == 0 || a > 1;

non_constant_annotation_constructor

#

注解创建只能调用 const 构造函数。

说明

#

当注解是现有构造函数的调用，而调用的构造函数不是 const 构造函数时，分析器会生成此诊断信息。

示例

#

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

dart
@C()
void f() {
}

class C {
  C();
}

常规修复

#

如果该类可以有 const 构造函数，则创建一个可用于注解的 const 构造函数：

dart
@C()
void f() {
}

class C {
  const C();
}

如果该类不能有 const 构造函数，则删除注解或对注解使用不同的类。

non_constant_case_expression

#

case 表达式必须是常量。

说明

#

当 case 子句中的表达式不是常量表达式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 j 不是常量：

dart
void f(int i, int j) {
  switch (i) {
    case j:
      // ...
      break;
  }
}

常规#### 常规修复

#

更改映射使其成为常量映射。在展开示例中，您可以通过使被展开的集合成为常量来实现：

dart
const notConst = <int, int>{};
var map = const <int, int>{...notConst};

如果映射不需要是常量映射，则删除 const 关键字：

dart
bool notConst = true;
var map = <int, int>{if (notConst) 1 : 2};

non_constant_map_key

#

const 映射字面量中的键必须是常量。

说明

#

当常量映射字面量中的键不是常量值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 a 不是常量：

dart
var a = 'a';
var m = const {a: 0};

常规修复

#

如果映射需要是常量映射，则使键成为常量：

dart
const a = 'a';
var m = const {a: 0};

如果映射不需要是常量映射，则删除 const 关键字：

dart
var a = 'a';
var m = {a: 0};

non_constant_map_pattern_key

#

映射模式中的键表达式必须是常量。

说明

#

当映射模式中的键不是常量表达式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为键 A() 不是常量：

dart
void f(Object x) {
  if (x case {A(): 0}) {}
}

class A {
  const A();
}

常规修复

#

对键使用常量：

dart
void f(Object x) {
  if (x case {const A(): 0}) {}
}

class A {
  const A();
}

non_constant_map_value

#

const 映射字面量中的值必须是常量。

说明

#

当常量映射字面量中的值不是常量值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 a 不是常量：

dart
var a = 'a';
var m = const {0: a};

常规修复

#

如果映射需要是常量映射，则使键成为常量：

dart
const a = 'a';
var m = const {0: a};

如果映射不需要是常量映射，则删除 const 关键字：

dart
var a = 'a';
var m = {0: a};

non_constant_relational_pattern_expression

#

关系模式表达式必须是常量。

说明

#

当关系模式表达式中的值不是常量表达式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 > 运算符的操作数 a 不是常量：

dart
final a = 0;

void f(int x) {
  if (x case > a) {}
}

常规修复

#

将该值替换为常量表达式：

dart
const a = 0;

void f(int x) {
  if (x case > a) {}
}

non_constant_set_element

#

const 集合字面量中的值必须是常量。

说明

#

当常量集合字面量包含不是编译时常量的元素时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 i 不是常量：

dart
var i = 0;

var s = const {i};

常规修复

#

如果元素可以更改为常量，则更改它：

dart
const i = 0;

var s = const {i};

如果元素不能是常量，则删除关键字 const ：

dart
var i = 0;

var s = {i};

non_constant_type_argument

#

'{0}' 的类型参数必须在编译时已知，因此不能是类型参数。

说明

#

当方法的类型参数需要在编译时已知，但类型参数（其值在编译时无法知道）用作类型参数时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为 Pointer.asFunction 的类型参数必须在编译时已知，但类型参数 R （在编译时未知）用作类型参数：

dart
import 'dart:ffi';

typedef T = int Function(int);

class C<R extends T> {
  void m(Pointer<NativeFunction<T>> p) {
    p.asFunction<R>();
  }
}

常规修复

#

删除任何类型参数的使用：

dart
import 'dart:ffi';

class C {
  void m(Pointer<NativeFunction<Int64 Function(Int64)>> p) {
    p.asFunction<int Function(int)>();
  }
}

non_const_argument_for_const_parameter

#

参数 '{0}' 必须是常量。

说明

#

当参数用 mustBeConst 注解注释，并且相应的参数不是常量表达式时，分析器会生成此诊断信息。

示例

#

以下代码在调用函数 f 时会生成此诊断信息，因为传递给函数 g 的参数的值不是常量：

dart
import 'package:meta/meta.dart' show mustBeConst;

int f(int value) => g(value);

int g(@mustBeConst int value) => value + 1;

常规修复

#

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

dart
import 'package:meta/meta.dart' show mustBeConst;

const v = 3;

int f() => g(v);

int g(@mustBeConst int value) => value + 1;

non_const_call_to_literal_constructor

#

此实例创建必须是 'const'，因为 {0} 构造函数被标记为 '@literal'。

说明

#

当使用 const 关键字调用具有 literal 注解的构造函数时，分析器会生成此诊断信息，但构造函数的所有参数都是常量。该注解指示应尽可能使用构造函数创建常量值。

示例

#

以下代码会生成此诊断信息：

dart
import 'package:meta/meta.dart';

class C {
  @literal
  const C();
}

C f() => C();

常规修复

#

在构造函数调用之前添加关键字 const ：

dart
import 'package:meta/meta.dart';

class C {
  @literal
  const C();
}

void f() => const C();

non_const_generative_enum_constructor

#

生成式枚举构造函数必须是 'const'。

说明

#

当枚举声明包含未标记为 const 的生成式构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 E 中的构造函数未标记为 const ：

dart
enum E {
  e;

  E() ;
}

常规修复

#

在构造函数之前添加 const 关键字：

dart
enum E {
  e;

  const E();
}

non_covariant_type_parameter_position_in_representation_type

#

扩展类型参数不能在其表示类型的非协变位置使用。

说明

#

当扩展类型的类型参数在其扩展类型的表示类型的非协变位置使用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类型参数 T 在函数类型 void Function(T) 中用作参数类型，而参数不是协变的：

dart
extension type A<T>(void Function(T) f) {}

常规修复

#

删除类型参数的使用：

dart
extension type A(void Function(String) f) {}

non_exhaustive_switch_expression

#

类型 '{0}' 未被 switch cases 穷尽匹配，因为它不匹配 '{1}'。

说明

#

当 switch 表达式缺少一个或多个可能流经它的值的 case 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 switch 表达式没有 E.three 值的 case：

dart
enum E { one, two, three }

String f(E e) => switch (e) {
    E.one => 'one',
    E.two => 'two',
  };

常规修复

#

如果 switch 表达式对缺少的值有特殊的意义，则为每个缺少匹配的值添加一个 case：

dart
enum E { one, two, three }

String f(E e) => switch (e) {
    E.one => 'one',
    E.two => 'two',
    E.three => 'three',
  };

如果不需要匹配缺少的值，则添加一个通配符模式，返回一个简单的默认值：

dart
enum E { one, two, three }

String f(E e) => switch (e) {
    E.one => 'one',
    E.two => 'two',
    _ => 'unknown',
  };

请注意，通配符模式将处理将来添加到类型的任何值。如果您需要更新 switch 以解释新添加的类型，则会失去编译器警告您的能力。

non_exhaustive_switch_statement

#

类型 '{0}' 未被 switch cases 穷尽匹配，因为它不匹配 '{1}'。

说明

#

当 switch 语句切换穷尽类型时，如果缺少一个或多个可能流经它的值的 case，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 switch 语句没有 E.three 值的 case，而 E 是穷尽类型：

dart
enum E { one, two, three }

void f(E e) {
  switch (e) {
    case E.one:
    case E.two:
  }
}

常规修复

#

为当前未匹配的每个常量添加一个 case：

dart
enum E { one, two, three }

void f(E e) {
  switch (e) {
    case E.one:
    case E.two:
      break;
    case E.three:
  }
}

如果不需要匹配缺少的值，则添加 default 子句或通配符模式：

dart
enum E { one, two, three }

void f(E e) {
  switch (e) {
    case E.one:
    case E.two:
      break;
    default:
  }
}

但请注意，添加 default 子句或通配符模式将导致穷尽类型的任何将来值也被处理，因此您将失去编译器警告您是否需要更新 switch 的能力。

non_final_field_in_enum

#

枚举只能声明 final 字段。

说明

#

当枚举中的实例字段未标记为 final 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 f 不是 final 字段：

dart
enum E {
  c;

  int f = 0;
}

常规修复

#

如果必须为枚举定义该字段，则将该字段标记为 final ：

dart
enum E {
  c;

  final int f = 0;
}

如果可以删除该字段，则将其删除：

dart
enum E {
  c
}

non_generative_constructor

#

预期生成式构造函数 '{0}'，但找到了工厂构造函数。

说明

#

当构造函数的初始化器列表调用超类的构造函数，并且调用的构造函数是工厂构造函数时，分析器会生成此诊断信息。只有生成式构造函数才能在初始化器列表中调用。

示例

#

以下代码会生成此诊断信息，因为 super.one() 的调用正在调用工厂构造函数：

dart
class A {
  factory A.one() = B;
  A.two();
}

class B extends A {
  B() : super.one();
}

常规修复

#

更改超类调用以调用生成式构造函数：

dart
class A {
  factory A.one() = B;
  A.two();
}

class B extends A {
  B() : super.two();
}

常规修复

#

如果可以将字段的类型更改为与注解匹配，则更改它：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int32()
  external int x;
}

如果注解正确，则更改字段的类型以匹配：

dart
import 'dart:ffi';

final class C extends Struct {
  @Double()
  external double x;
}

missing_annotation_on_struct_field

#

' {1}' 的子类中类型为 '{0}' 的字段必须有一个注解来指示本机类型。

说明

#

当 Struct 或 Union 的子类中的字段类型需要注解，但没有注解时，分析器会生成此诊断信息。Dart 类型 int 、 double 和 Array 用于表示多个 C 类型，注解指定字段表示的兼容 C 类型。

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

示例

#

以下代码会生成此诊断信息，因为字段 x 没有注解来指示整数值的底层宽度：

dart
import 'dart:ffi';

final class C extends Struct {
  external int x;
}

常规修复

#

向字段添加适当的注解：

dart
import 'dart:ffi';

final class C extends Struct {
  @Int64()
  external int x;
}

missing_dart_library

#

缺少必需的库 '{0}'。

说明

#

当 Dart 或 Flutter SDK 安装不正确，因此找不到 dart: 库之一时，分析器会生成此诊断信息。

常规修复

#

重新安装 Dart 或 Flutter SDK。

missing_default_value_for_parameter

#

参数 '{0}' 不能具有 'null' 值，因为它类型，但隐式默认值为 'null'。

使用空安全时，使用 'required' 关键字，而不是 '@required' 注解。

说明

#

当可选参数（位置参数或命名参数）具有 潜在的非空类型 并且没有指定默认值时，分析器会生成此诊断信息。没有显式默认值的可选参数的隐式默认值为 null 。如果参数的类型不允许参数具有 null 值，则隐式默认值无效。

示例

#

以下代码会生成此诊断信息，因为 x 不能为 null ，并且没有指定非 null 默认值：

dart
void f([int x]) {}

同样，以下代码也会生成此诊断信息：

dart
void g({int x}) {}

常规修复

#

如果您想使用 null 来指示没有提供值，则需要使类型可为空：

dart
void f([int? x]) {}
void g({int? x}) {}

如果参数不能为 null，则提供默认值：

dart
void f([int x = 1]) {}
void g({int x = 2}) {}

或者将参数设为必需参数：

dart
void f(int x) {}
void g({required int x}) {}

missing_dependency

#

缺少对导入的包 '{0}' 的依赖。

说明

#

当源代码中已导入但未列为导入包的依赖项的包时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为包 path 未列为依赖项，而在包 example 的源代码中有一个导入语句使用了包 path ：

yaml
name: example
dependencies:
  meta: ^1.0.2

常规修复

#

将缺少的包 path 添加到 dependencies 字段：

yaml
name: example
dependencies:
  meta: ^1.0.2
  path: any

missing_enum_constant_in_switch

#

缺少 '{0}' 的 case 子句。

说明

#

当枚举的 switch 语句未包含枚举中值之一的选项时，分析器会生成此诊断信息。

请注意， null 始终是枚举的可能值，因此也必须进行处理。

示例

#

以下代码会生成此诊断信息，因为未处理枚举值 e2 ：

dart
enum E { e1, e2 }

void f(E e) {
  switch (e) {
    case E.e1:
      break;
  }
}

常规修复

#

如果对缺少的值有特殊的处理，则为每个缺少的值添加一个 case 子句：

dart
enum E { e1, e2 }

void f(E e) {
  switch (e) {
    case E.e1:
      break;
    case E.e2:
      break;
  }
}

如果应以相同的方式处理缺少的值，则添加 default 子句：

dart
enum E { e1, e2 }

void f(E e) {
  switch (e) {
    case E.e1:
      break;
    default:
      break;
  }
}

missing_exception_value

#

当函数的返回类型既不是 'void'、'Handle' 也不是 'Pointer' 时，方法 {0} 必须有异常返回值（第二个参数）。

说明

#

当 Pointer.fromFunction 或 NativeCallable.isolateLocal 的调用在调用的返回类型既不是 void 、 Handle 也不是 Pointer 时没有第二个参数（异常返回值）时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为 f 返回的类型应为 8 位整数，但对 fromFunction 的调用不包含异常返回参数：

dart
import 'dart:ffi';

int f(int i) => i * 2;

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

常规修复

#

添加异常返回类型：

dart
import 'dart:ffi';

int f(int i) => i * 2;

void g() {
  Pointer.fromFunction<Int8 Function(Int8)>(f, 0);
}

missing_field_type_in_struct

#

结构体类中的字段必须有显式声明的类型 'int'、'double' 或 'Pointer'。

说明

#

当 Struct 或 Union 的子类中的字段没有类型注解时，分析器会生成此诊断信息。每个字段都必须有显式类型，并且该类型必须是 int 、 double 、 Pointer 或 Struct 或 Union 的子类。

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

示例

#

以下代码会生成此诊断信息，因为字段 str 没有类型注解：

dart
import 'dart:ffi';

final class C extends Struct {
  external var str;

  @Int32()
  external int i;
}

常规修复

#

显式指定字段的类型：

dart
import 'dart:ffi';
import 'package:ffi/ffi.dart';

final class C extends Struct {
  external Pointer<Utf8> str;

  @Int32()
  external int i;
}

missing_name

#

'name' 字段是必需的，但缺失。

说明

#

当没有顶级 name 键时，分析器会生成此诊断信息。 name 键提供包的名称，这是必需的。

示例

#

以下代码会生成此诊断信息，因为该包没有名称：

yaml
dependencies:
  meta: ^1.0.2

常规修复

#

添加顶级键 name ，其值为包的名称：

yaml
name: example
dependencies:
  meta: ^1.0.2

missing_named_pattern_field_name

#

getter 名称未显式指定，模式也不是变量。

说明

#

当在对象模式中，属性的规范和用于匹配属性值的模式既没有：

  • 冒号之前的 getter 名称
  • 可以从中推断 getter 名称的变量模式

时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为在对象模式（ C(:0) ）中，冒号前没有 getter 名称，冒号后也没有变量模式：

dart
abstract class C {
  int get f;
}

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

常规修复

#

如果您需要在模式的作用域内使用属性的实际值，则添加一个变量模式，其中变量的名称与要匹配的属性的名称相同：

dart
abstract class C {
  int get f;
}

void f(C c) {
  switch (c) {
    case C(:var f) when f == 0:
      print(f);
  }
}

如果您不需要在模式的作用域内使用属性的实际值，则在冒号前添加要匹配的属性的名称：

dart
abstract class C {
  int get f;
}

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

missing_override_of_must_be_overridden

#

缺少 '{0}' 的具体实现。

缺少 '{0}' 和 '{1}' 的具体实现。

缺少 '{0}'、'{1}' 和其他 {2} 个具体实现。

缺少 '{0}'、'{1}'、'{2}' 和 '{3}' 的具体实现。

缺少 '{0}'、'{1}' 和 '{2}' 的具体实现。

说明

#

当具有 @mustBeOverridden 注解的实例成员未在子类中被覆盖时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 B 没有继承方法 A.m 的覆盖，而 A.m 用 @mustBeOverridden 注解注释：

dart
import 'package:meta/meta.dart';

class A {
  @mustBeOverridden
  void m() {}
}

class B extends A {}

常规修复

#

如果注解适合该成员，则在子类中覆盖该成员：

dart
import 'package:meta/meta.dart';

class A {
  @mustBeOverridden
  void m() {}
}

class B extends A {
  @override
  void m() {}
}

如果注解不适合该成员，则删除该注解：

dart
class A {
  void m() {}
}

class B extends A {}

missing_required_argument

#

命名参数 '{0}' 是必需的，但没有相应的参数。

说明

#

当函数的调用缺少必需的命名参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 的调用不包含缺少的必需命名参数 end 的值：

dart
void f(int start, {required int end}) {}
void g() {
  f(3) ;
}

常规修复

#

添加与缺少的必需参数对应的命名参数：

dart
void f(int start, {required int end}) {}
void g() {
  f(3, end: 5);
}

missing_required_param

#

参数 '{0}' 是必需的。

参数 '{0}' 是必需的。{1}。

说明

#

当调用具有被注释为必需的命名参数的方法或函数时，并且没有为该参数提供值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为命名参数 x 是必需的：

dart
import 'package:meta/meta.dart';

void f({@required int? x}) {}

void g() {
  f() ;
}

常规修复

#

提供所需的值：

dart
import 'package:meta/meta.dart';

void f({@required int? x}) {}

void g() {
  f(x: 2);
}

missing_return

#

此函数的返回类型为 '{0}'，但没有以 return 语句结束。

说明

#

任何不以显式返回或抛出结束的函数或方法都会隐式返回 null 。这很少是预期的行为。当分析器找到隐式返回时，它会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 没有以返回结束：

dart
int f(int x) {
  if (x < 0) {
    return 0;
  }
}
#### 说明

当声明字段并具有以下所有特征时，分析器会生成此诊断信息：
- 具有 [潜在的非空类型](/resources/glossary#potentially-non-nullable)
- 没有初始化器
- 未标记为 `late`

#### 示例

以下代码会生成此诊断信息，因为 `x` 在不允许为 `null` 时隐式初始化为 `null` ：

```dart
class C {
  int x;
}

类似地，以下代码会生成此诊断信息，因为 x 在不允许为 null 时被其中一个构造函数隐式初始化为 null ，即使它由其他构造函数初始化：

dart
class C {
  int x;

  C(this.x);

  C.n();
}

常规修复

#

如果所有实例的字段都有合理的默认值，则添加初始化表达式：

dart
class C {
  int x = 0;
}

如果在创建实例时应提供字段的值，则添加一个设置字段值的构造函数或更新现有构造函数：

dart
class C {
  int x;

  C(this.x);
}

您还可以将字段标记为 late ，这将删除诊断信息，但如果在访问字段之前未为其赋值，则会导致在运行时抛出异常。只有在您确定字段在引用之前将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
class C {
  late int x;
}

not_initialized_non_nullable_variable

#

非空变量 '{0}' 必须初始化。

说明

#

当静态字段或顶级变量具有非空类型并且没有初始化器时，分析器会生成此诊断信息。通常，没有初始化器的字段和变量被初始化为 null ，但字段或变量的类型不允许将其设置为 null ，因此必须提供显式初始化器。

示例

#

以下代码会生成此诊断信息，因为字段 f 不能初始化为 null ：

dart
class C {
  static int f;
}

类似地，以下代码会生成此诊断信息，因为顶级变量 v 不能初始化为 null ：

dart
int v;

常规修复

#

如果字段或变量不能初始化为 null ，则添加一个将其设置为非空值的初始化器：

dart
class C {
  static int f = 0;
}

如果字段或变量应初始化为 null ，则将类型更改为可为空：

dart
int? v;

如果字段或变量不能在声明中初始化，但在引用之前将始终初始化，则将其标记为 late ：

dart
class C {
  static late int f;
}

not_iterable_spread

#

列表或集合字面量中的展开元素必须实现 'Iterable'。

说明

#

当出现在列表字面量或集合字面量中的展开元素的表达式的静态类型没有实现类型 Iterable 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m};

常规修复

#

最常见的修复方法是用产生可迭代对象的表达式替换该表达式：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m.keys};

not_map_spread

#

映射字面量中的展开元素必须实现 'Map'。

说明

#

当出现在映射字面量中的展开元素的表达式的静态类型没有实现类型 Map 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 l 不是 Map ：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l};

常规修复

#

最常见的修复方法是用产生映射的表达式替换该表达式：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l.asMap()};

no_annotation_constructor_arguments

#

注解创建必须有参数。

说明

#

当注解由单个标识符组成，但该标识符是类的名称而不是变量的名称时，分析器会生成此诊断信息。要创建类的实例，标识符后必须跟一个参数列表。

示例

#

以下代码会生成此诊断信息，因为 C 是一个类，并且如果没有从类中调用 const 构造函数，则不能将类用作注解：

dart
class C {
  const C();
}

@C
var x;

常规修复

#

添加缺少的参数列表：

dart
class C {
  const C();
}

@C()
var x;

no_combined_super_signature

#

无法从被覆盖的方法推断 '{0}' 中缺少的类型：{1}。

说明

#

当存在需要推断一个或多个类型的函数声明，并且由于没有被覆盖的方法的函数类型是所有其他被覆盖方法的超类型（如 覆盖推断 所指定）时，无法推断这些类型，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 C 中声明的方法 m 缺少返回类型和参数 a 的类型，并且无法为其推断任何缺少的类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  m(a) ;
}

在此示例中，无法执行覆盖推断，因为被覆盖的方法在以下方面不兼容：

  • 参数类型（ String 和 int ）都不是对方的超类型。
  • 返回类型都不是对方的子类型。

常规修复

#

如果可能，向子类中与所有被覆盖方法的类型一致的方法添加类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  C m(Object a);
}

no_generative_constructors_in_superclass

#

类 '{0}' 不能扩展 '{1}'，因为 '{1}' 只有工厂构造函数（没有生成式构造函数），而 '{0}' 至少有一个生成式构造函数。

说明

#

当至少有一个生成式构造函数（无论是显式还是隐式的）的类具有没有生成式构造函数的超类时，分析器会生成此诊断信息。每个生成式构造函数（除在 Object 中定义的构造函数外）都显式或隐式地调用其超类的一个生成式构造函数。

示例

#

以下代码会生成此诊断信息，因为类 B 有一个隐式生成式构造函数，它不能调用 A 中的生成式构造函数，因为 A 没有生成式构造函数：

dart
class A {
  factory A.none() => throw '';
}

class B extends A {}

常规修复

#

如果超类应该有生成式构造函数，则添加一个：

dart
class A {
  A();
  factory A.none() => throw '';
}

class B extends A {}

如果子类不应该有生成式构造函数，则通过添加工厂构造函数将其删除：

dart
class A {
  factory A.none() => throw '';
}

class B extends A {
  factory B.none() => throw '';
}

如果子类必须有生成式构造函数，但超类不能有，则实现超类而不是扩展它：

dart
class A {
  factory A.none() => throw '';
}

class B implements A {}

nullable_type_in_catch_clause

#

潜在的可空类型不能用于 'on' 子句中，因为它无法抛出可空表达式。

说明

#

当 catch 子句中的 on 后的类型是可空类型时，分析器会生成此诊断信息。指定可空类型是无效的，因为不可能捕获 null （因为抛出 null 是运行时错误）。

示例

#

以下代码会生成此诊断信息，因为异常类型指定允许 null ，而 null 不能被抛出：

dart
void f() {
  try {
    // ...
  } on FormatException? {
  }
}

常规修复

#

从类型中删除问号：

dart
void f() {
  try {
    // ...
  } on FormatException {
  }
}

nullable_type_in_extends_clause

#

类不能扩展可空类型。

说明

#

当类声明使用 extends 子句指定超类，并且超类后跟一个 ? 时，分析器会生成此诊断信息。

指定可空超类是无效的，因为这样做没有任何意义；它不会更改包含 extends 子句的类继承的接口或实现。

但是，请注意，将可空类型用作超类的类型参数是有效的，例如 class A extends B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 extends 子句中：

dart
class A {}
class B extends A? {}

常规修复

#

从类型中删除问号：

dart
class A {}
class B extends A {}

nullable_type_in_implements_clause

#

类、mixin 或扩展类型不能实现可空类型。

说明

#

当类、mixin 或扩展类型声明具有 implements 子句，并且接口后跟一个 ? 时，分析器会生成此诊断信息。

指定可空接口是无效的，因为这样做没有任何意义；它不会更改包含 implements 子句的类继承的接口。

但是，请注意，将可空类型用作接口的类型参数是有效的，例如 class A implements B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 implements 子句中：

dart
class A {}
class B implements A? {}

常规修复

#

从类型中删除问号：

dart
class A {}
class B implements A {}

nullable_type_in_on_clause

#

mixin 不能具有可空类型作为超类约束。

说明

#

当 mixin 声明使用 on 子句指定超类约束，并且指定的类后跟一个 ? 时，分析器会生成此诊断信息。

指定可空超类约束是无效的，因为这样做没有任何意义；它不会更改包含 on 子句的 mixin 所依赖的接口。

但是，请注意，将可空类型用作超类约束的类型参数是有效的，例如 mixin A on B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 on 子句中：

dart
class C {}
mixin M on C? {}

常规修复

#

从类型中删除问号：

dart
class C {}
mixin M on C {}

nullable_type_in_with_clause

#

类或 mixin 不能混合可空类型。

说明

#

当类或 mixin 声明具有 with 子句，并且 mixin 后跟一个 ? 时，分析器会生成此诊断信息。

指定可空 mixin 是无效的，因为这样做没有任何意义；它不会更改包含 with 子句的类继承的接口或实现。

但是，请注意，将可空类型用作 mixin 的类型参数是有效的，例如 class A with B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 with 子句中：

dart
mixin M {}
class C with M? {}

常规修复

#

从类型中删除问号：

dart
mixin M {}
class C with M {}

null_argument_to_non_null_type

#

' {0}' 不应为非空类型参数 '{1}' 调用具有 'null' 参数的值。

说明

#

当声明字段并具有以下所有特征时，分析器会生成此诊断信息：

示例

#

以下代码会生成此诊断信息，因为 x 在不允许为 null 时隐式初始化为 null ：

dart
class C {
  int x;
}

类似地，以下代码会生成此诊断信息，因为 x 在不允许为 null 时被其中一个构造函数隐式初始化为 null ，即使它由其他构造函数初始化：

dart
class C {
  int x;

  C(this.x);

  C.n();
}

常规修复

#

如果所有实例的字段都有合理的默认值，则添加初始化表达式：

dart
class C {
  int x = 0;
}

如果在创建实例时应提供字段的值，则添加一个设置字段值的构造函数或更新现有构造函数：

dart
class C {
  int x;

  C(this.x);
}

您还可以将字段标记为 late ，这将删除诊断信息，但如果在访问字段之前未为其赋值，则会导致在运行时抛出异常。只有在您确定字段在引用之前将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
class C {
  late int x;
}

not_initialized_non_nullable_variable

#

非空变量 '{0}' 必须初始化。

说明

#

当静态字段或顶级变量具有非空类型并且没有初始化器时，分析器会生成此诊断信息。通常，没有初始化器的字段和变量被初始化为 null ，但字段或变量的类型不允许将其设置为 null ，因此必须提供显式初始化器。

示例

#

以下代码会生成此诊断信息，因为字段 f 不能初始化为 null ：

dart
class C {
  static int f;
}

类似地，以下代码会生成此诊断信息，因为顶级变量 v 不能初始化为 null ：

dart
int v;

常规修复

#

如果字段或变量不能初始化为 null ，则添加一个将其设置为非空值的初始化器：

dart
class C {
  static int f = 0;
}

如果字段或变量应初始化为 null ，则将类型更改为可为空：

dart
int? v;

如果字段或变量不能在声明中初始化，但在引用之前将始终初始化，则将其标记为 late ：

dart
class C {
  static late int f;
}

not_iterable_spread

#

列表或集合字面量中的展开元素必须实现 'Iterable'。

说明

#

当出现在列表字面量或集合字面量中的展开元素的表达式的静态类型没有实现类型 Iterable 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m};

常规修复

#

最常见的修复方法是用产生可迭代对象的表达式替换该表达式：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m.keys};

not_map_spread

#

映射字面量中的展开元素必须实现 'Map'。

说明

#

当出现在映射字面量中的展开元素的表达式的静态类型没有实现类型 Map 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 l 不是 Map ：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l};

常规修复

#

最常见的修复方法是用产生映射的表达式替换该表达式：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l.asMap()};

no_annotation_constructor_arguments

#

注解创建必须有参数。

说明

#

当注解由单个标识符组成，但该标识符是类的名称而不是变量的名称时，分析器会生成此诊断信息。要创建类的实例，标识符后必须跟一个参数列表。

示例

#

以下代码会生成此诊断信息，因为 C 是一个类，并且如果没有从类中调用 const 构造函数，则不能将类用作注解：

dart
class C {
  const C();
}

@C
var x;

常规修复

#

添加缺少的参数列表：

dart
class C {
  const C();
}

@C()
var x;

no_combined_super_signature

#

无法从被覆盖的方法推断 '{0}' 中缺少的类型：{1}。

说明

#

当存在需要推断一个或多个类型的函数声明，并且由于没有被覆盖的方法的函数类型是所有其他被覆盖方法的超类型（如 覆盖推断 所指定）时，无法推断这些类型，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 C 中声明的方法 m 缺少返回类型和参数 a 的类型，并且无法为其推断任何缺少的类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  m(a) ;
}

在此示例中，无法执行覆盖推断，因为被覆盖的方法在以下方面不兼容：

  • 参数类型（ String 和 int ）都不是对方的超类型。
  • 返回类型都不是对方的子类型。

常规修复

#

如果可能，向子类中与所有被覆盖方法的类型一致的方法添加类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  C m(Object a);
}

no_generative_constructors_in_superclass

#

类 '{0}' 不能扩展 '{1}'，因为 '{1}' 只有工厂构造函数（没有生成式构造函数），而 '{0}' 至少有一个生成式构造函数。

说明

#

当至少有一个生成式构造函数（无论是显式还是隐式的）的类具有没有生成式构造函数的超类时，分析器会生成此诊断信息。每个生成式构造函数（除在 Object 中定义的构造函数外）都显式或隐式地调用其超类的一个生成式构造函数。

示例

#

以下代码会生成此诊断信息，因为类 B 有一个隐式生成式构造函数，它不能调用 A 中的生成式构造函数，因为 A 没有生成式构造函数：

dart
class A {
  factory A.none() => throw '';
}

class B extends A {}

常规修复

#

如果超类应该有生成式构造函数，则添加一个：

dart
class A {
  A();
  factory A.none() => throw '';
}

class B extends A {}

如果子类不应该有生成式构造函数，则通过添加工厂构造函数将其删除：

dart
class A {
  factory A.none() => throw '';
}

class B extends A {
  factory B.none() => throw '';
}

如果子类必须有生成式构造函数，但超类不能有，则实现超类而不是扩展它：

dart
class A {
  factory A.none() => throw '';
}

class B implements A {}

nullable_type_in_catch_clause

#

潜在的可空类型不能用于 'on' 子句中，因为它无法抛出可空表达式。

说明

#

当 catch 子句中的 on 后的类型是可空类型时，分析器会生成此诊断信息。指定可空类型是无效的，因为不可能捕获 null （因为抛出 null 是运行时错误）。

示例

#

以下代码会生成此诊断信息，因为异常类型指定允许 null ，而 null 不能被抛出：

dart
void f() {
  try {
    // ...
  } on FormatException? {
  }
}

常规修复

#

从类型中删除问号：

dart
void f() {
  try {
    // ...
  } on FormatException {
  }
}

nullable_type_in_extends_clause

#

类不能扩展可空类型。

说明

#

当类声明使用 extends 子句指定超类，并且超类后跟一个 ? 时，分析器会生成此诊断信息。

指定可空超类是无效的，因为这样做没有任何意义；它不会更改包含 extends 子句的类继承的接口或实现。

但是，请注意，将可空类型用作超类的类型参数是有效的，例如 class A extends B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 extends 子句中：

dart
class A {}
class B extends A? {}

常规修复

#

从类型中删除问号：

dart
class A {}
class B extends A {}

nullable_type_in_implements_clause

#

类、mixin 或扩展类型不能实现可空类型。

说明

#

当类、mixin 或扩展类型声明具有 implements 子句，并且接口后跟一个 ? 时，分析器会生成此诊断信息。

指定可空接口是无效的，因为这样做没有任何意义；它不会更改包含 implements 子句的类继承的接口。

但是，请注意，将可空类型用作接口的类型参数是有效的，例如 class A implements B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 implements 子句中：

dart
class A {}
class B implements A? {}

常规修复

#

从类型中删除问号：

dart
class A {}
class B implements A {}

nullable_type_in_on_clause

#

mixin 不能具有可空类型作为超类约束。

说明

#

当 mixin 声明使用 on 子句指定超类约束，并且指定的类后跟一个 ? 时，分析器会生成此诊断信息。

指定可空超类约束是无效的，因为这样做没有任何意义；它不会更改包含 on 子句的 mixin 所依赖的接口。

但是，请注意，将可空类型用作超类约束的类型参数是有效的，例如 mixin A on B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 on 子句中：

dart
class C {}
mixin M on C? {}

常规修复

#

从类型中删除问号：

dart
class C {}
mixin M on C {}

nullable_type_in_with_clause

#

类或 mixin 不能混合可空类型。

说明

#

当类或 mixin 声明具有 with 子句，并且 mixin 后跟一个 ? 时，分析器会生成此诊断信息。

指定可空 mixin 是无效的，因为这样做没有任何意义；它不会更改包含 with 子句的类继承的接口或实现。

但是，请注意，将可空类型用作 mixin 的类型参数是有效的，例如 class A with B<C?> {} 。

示例

#

以下代码会生成此诊断信息，因为 A? 是可空类型，而可空类型不能用于 with 子句中：

dart
mixin M {}
class C with M? {}

常规修复

#

从类型中删除问号：

dart
mixin M {}
class C with M {}

null_argument_to_non_null_type

#

' {0}' 不应为非空类型参数 '{1}' 调用具有 'null' 参数的值。

说明

#

当将 null 传递给构造函数 Future.value 或方法 Completer.complete 时，分析器会生成此诊断信息，而用于创建实例的类型参数是非空的。即使类型系统无法表达此限制，传递 null 也会导致运行时异常。

示例

#

以下代码会生成此诊断信息，因为即使类型参数是非空类型 String ， null 也正在传递给构造函数 Future.value ：

dart
Future<String> f() {
  return Future.value(null);
}

常规修复

#

传递非空值：

dart
Future<String> f() {
  return Future.value('');
}

null_check_always_fails

#

此空检查将始终引发异常，因为表达式将始终计算为 'null'。

说明

#

当在值只能为 null 的表达式上使用空检查运算符 (!) 时，分析器会生成此诊断信息。在这种情况下，运算符始终会引发异常，这可能不是预期的行为。

示例

#

以下代码会生成此诊断信息，因为函数 g 将始终返回 null ，这意味着 f 中的空检查将始终抛出：

dart
void f() {
  g()!;
}

Null g() => null;

常规修复

#

如果您打算始终引发异常，则用显式的 throw 表达式替换空检查，以使意图更清晰：

dart
void f() {
  g();
  throw TypeError();
}

Null g() => null;

obsolete_colon_for_default_value

#

不再支持使用冒号作为默认值之前的分隔符。

说明

#

当冒号（ : ）用作可选命名参数的默认值之前的分隔符时，分析器会生成此诊断信息。虽然此语法曾经被允许，但它已被删除，建议使用等号（ = ）。

示例

#

以下代码会生成此诊断信息，因为在可选参数 i 的默认值之前使用了冒号：

dart
void f({int i : 0}) {}

常规修复

#

将冒号替换为等号：

dart
void f({int i = 0}) {}

on_repeated

#

类型 '{0}' 只能在超类约束中包含一次。

说明

#

当在 mixin 的超类约束中多次列出相同的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 在 M 的超类约束中出现了两次：

dart
mixin M on A, A {
}

class A {}
class B {}

常规修复

#

如果应在超类约束中包含不同的类型，则将其中一个出现替换为其他类型：

dart
mixin M on A, B {
}

class A {}
class B {}

如果没有其他类型，则删除重复的类型名称：

dart
mixin M on A {
}

class A {}
class B {}

optional_parameter_in_operator

#

定义运算符时不允许使用可选参数。

说明

#

当运算符声明中的一个或多个参数是可选参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为参数 other 是可选参数：

dart
class C {
  C operator +([C? other]) => this;
}

常规修复

#

使所有参数都是必需的参数：

dart
class C {
  C operator +(C other) => this;
}

override_on_non_overriding_member

#

该字段没有覆盖继承的 getter 或 setter。

该 getter 没有覆盖继承的 getter。

该方法没有覆盖继承的方法。

该 setter 没有覆盖继承的 setter。

说明

#

当类的成员用 @override 注解注释，但该成员未在类的任何超类型中声明时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 未在 C 的任何超类型中声明：

dart
class C {
  @override
  String m() => '';
}

常规修复

#

如果该成员旨在覆盖具有不同名称的成员，则将其更新为具有相同的名称：

dart
class C {
  @override
  String toString() => '';
}

如果该成员旨在覆盖从超类中删除的成员，则考虑从子类中删除该成员。

如果该成员不能被删除，则删除注解。

packed_annotation

#

结构体最多只能有一个 'Packed' 注解。

说明

#

当 Struct 的子类具有多个 Packed 注解时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为类 C 是 Struct 的子类，并且有两个 Packed 注解：

dart
import 'dart:ffi';

@Packed(1)
@Packed(1)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

常规修复

#

删除除一个注解之外的所有注解：

dart
import 'dart:ffi';

@Packed(1)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

packed_annotation_alignment

#

仅支持打包到 1、2、4、8 和 16 字节。

说明

#

当 Packed 注解的参数不是允许的值之一（1、2、4、8 或 16）时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为 Packed 注解（ 3 ）的参数不是允许的值之一：

dart
import 'dart:ffi';

@Packed(3)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

常规修复

#

将对齐更改为允许的值之一：

dart
import 'dart:ffi';

@Packed(4)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

part_of_different_library

#

预期此库是 '{0}' 的一部分，而不是 '{1}'。

说明

#

当库尝试将文件作为自身的一部分包含在内，而另一个文件是不同库的一部分时，分析器会生成此诊断信息。

示例

#

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

dart
part of 'library.dart';

以下代码（在除 library.dart 之外的任何文件中）会生成此诊断信息，因为它尝试将 part.dart 作为自身的一部分包含在内，而 part.dart 是不同库的一部分：

dart
part 'package:a/part.dart';

常规修复

#

如果库应该使用不同的文件作为一部分，则将部分指令中的 URI 更改为其他文件的 URI。

如果 部分文件 应该是此库的一部分，则将部分指令中的 URI（或库名）更新为正确库的 URI（或名称）。

part_of_non_part

#

包含的部分 '{0}' 必须有 part-of 指令。

说明

#

当找到部分指令，并且引用的文件没有 part-of 指令时，分析器会生成此诊断信息。

示例

#

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

dart
class A {}

以下代码会生成此诊断信息，因为 a.dart 不包含 part-of 指令：

dart
part 'a.dart';

常规修复

#

如果引用的文件旨在作为另一个库的一部分，则向该文件添加 part-of 指令：

dart
part of 'test.dart';

class A {}

如果引用的文件旨在作为库，则将部分指令替换为导入指令：

dart
import 'a.dart';

part_of_unnamed_library

#

库未命名。在 part-of 指令中，预期的是 URI，而不是库名 '{0}'。

说明

#

当没有 library 指令（因此没有名称）的库包含 part 指令，并且 部分文件 中的 part of 指令使用名称来指定它是哪个库的一部分时，分析器会生成此诊断信息。

示例

#

给定一个名为 part_file.dart 的 部分文件 ，其中包含以下代码：

dart
part of lib;

以下代码会生成此诊断信息，因为包含 部分文件 的库没有名称，即使 部分文件 使用名称来指定它是哪个库的一部分：

dart
part 'part_file.dart';

常规修复

#

更改 部分文件 中的 part of 指令，以通过 URI 指定其库：

dart
part of 'test.dart';

path_does_not_exist

#

路径 '{0}' 不存在。

说明

#

当依赖项的 path 键引用不存在的目录时，分析器会生成此诊断信息。

示例

#

假设目录 doesNotExist 不存在，则以下代码会生成此诊断信息，因为它被列为包的路径：

yaml
name: example
dependencies:
  local_package:
    path: doesNotExist

常规修复

#

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

如果路径不正确，则将路径更改为与包根目录的路径匹配。

path_not_posix

#

路径 '{0}' 不是 POSIX 样式路径。

说明

#

当依赖项的 path 键的值是字符串，但不是 POSIX 样式路径时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 path 键后面的路径是 Windows 路径：

yaml
name: example
dependencies:
  local_package:
    path: E:\local_package

常规修复

#

将路径转换为 POSIX 路径。

path_pubspec_does_not_exist

#

目录 '{0}' 不包含 pubspec。

说明

#

当依赖项的 path 键引用不包含 pubspec.yaml 文件的目录时，分析器会生成此诊断信息。

示例

#

假设目录 local_package 不包含文件 pubspec.yaml ，则以下代码会生成此诊断信息，因为它被列为包的路径：

yaml
name: example
dependencies:
  local_package:
    path: local_package

常规修复

#

如果路径旨在作为包的根目录，则在目录中添加 pubspec.yaml 文件：

yaml
name: local_package

如果路径错误，则将其替换为正确的路径。

pattern_assignment_not_local_variable

#

只有局部变量才能在模式赋值中赋值。

说明

#

当模式赋值将值赋值给局部变量以外的任何内容时，分析器会生成此诊断信息。模式不能赋值给字段或顶级变量。

示例

#

如果使用模式解构时代码更简洁，则重写代码以在模式声明中将值赋值给局部变量，单独赋值非局部变量：

dart
class C {
  var x = 0;

  void f((int, int) r) {
    (x, _) = r;
  }
}

常规修复

#

如果使用模式赋值时代码更简洁，则重写代码以将值赋值给局部变量，单独赋值非局部变量：

dart
class C {
  var x = 0;

  void f((int, int) r) {
    var (a, _) = r;
    x = a;
  }
}

如果不用模式赋值时代码更简洁，则重写代码以不使用模式赋值：

dart
class C {
  var x = 0;

  void f((int, int) r) {
    x = r.$1;
  }
}

pattern_constant_from_deferred_library

#

来自延迟加载库的常量值不能用于模式中。

说明

#

当模式包含在不同库中声明的值，并且该库使用延迟导入导入时，分析器会生成此诊断信息。

说明

#

当模式包含在不同库中声明的值，并且该库使用延迟导入导入时，分析器会生成此诊断信息。常量在编译时计算，但来自延迟加载库的值在编译时不可用。

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

示例

#

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

dart
const zero = 0;

以下代码会生成此诊断信息，因为常量模式 a.zero 使用延迟导入导入：

dart
import 'a.dart' deferred as a;

void f(int x) {
  switch (x) {
    case a.zero:
      // ...
      break;
  }
}

常规修复

#

如果您需要引用导入库中的常量，则删除 deferred 关键字：

dart
import 'a.dart' as a;

void f(int x) {
  switch (x) {
    case a.zero:
      // ...
      break;
  }
}

如果您需要引用导入库中的常量并且还需要延迟加载导入的库，则将 switch 语句重写为一系列 if 语句：

dart
import 'a.dart' deferred as a;

void f(int x) {
  if (x == a.zero) {
    // ...
  }
}

如果您不需要引用该常量，则替换 case 表达式：

dart
void f(int x) {
  switch (x) {
    case 0:
      // ...
      break;
  }
}

pattern_type_mismatch_in_irrefutable_context

#

类型为 '{0}' 的匹配值无法赋值给所需的类型 '{1}'。

说明

#

当模式赋值或模式声明的右侧的值的类型与用于匹配它的模式所需的类型不匹配时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 可能不是 String ，因此可能与对象模式不匹配：

dart
void f(Object x) {
  var String(length: a) = x;
  print(a);
}

常规修复

#

更改右侧表达式的类型，使其与模式所需的类型匹配：

dart
void f(String x) {
  var String(length: a) = x;
  print(a);
}

pattern_variable_assignment_inside_guard

#

不能在封闭受保护模式的保护子句中赋值模式变量。

说明

#

当在保护（ when ）子句中为模式变量赋值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 a 在保护子句中被赋值：

dart
void f(int x) {
  if (x case var a when (a = 1) > 0) {
    print(a);
  }
}

常规修复

#

如果您需要捕获某个值，则将其赋值给不同的变量：

dart
void f(int x) {
  var b;
  if (x case var a when (b = 1) > 0) {
    print(a + b);
  }
}

如果您不需要捕获任何值，则删除赋值：

dart
void f(int x) {
  if (x case var a when 1 > 0) {
    print(a);
  }
}

platform_value_disallowed

#

'platforms' 字段中的键不能有值。

说明

#

当 platforms 映射中的键有值时，分析器会生成此诊断信息。 要了解有关指定包支持的平台的更多信息，请查看 平台声明文档 。

示例

#

以下 pubspec.yaml 会生成此诊断信息，因为键 web 有一个值。

yaml
name: example
platforms:
  web: "chrome"

常规修复

#

省略值并将键保留为空值：

yaml
name: example
platforms:
  web:

platforms 字段中键的值当前保留用于潜在的未来行为。

positional_field_in_object_pattern

#

对象模式只能使用命名字段。

说明

#

当对象模式包含一个字段而不指定 getter 名称时，分析器会生成此诊断信息。对象模式字段与对象 getter 返回的值匹配。如果没有指定 getter 名称，则模式字段无法访问要尝试匹配的值。

示例

#

以下代码会生成此诊断信息，因为对象模式 String(1) 没有指定要访问和与值 1 进行比较的 String 的 getter：

dart
void f(Object o) {
  if (o case String(1)) {}
}

常规修复

#

添加 getter 名称以访问该值，然后在要匹配的模式之前添加冒号：

dart
void f(Object o) {
  if (o case String(length: 1)) {}
}

positional_super_formal_parameter_with_positional_argument

#

当超类构造函数调用具有位置参数时，不能使用位置超类参数。

说明

#

当提供给超类构造函数的一些（但不是全部）位置参数使用超类参数时，分析器会生成此诊断信息。

位置超类参数与其索引中的超类构造函数中的位置参数相关联。也就是说，第一个超类参数与超类构造函数中的第一个位置参数相关联，第二个与第二个相关联，依此类推。位置参数也是如此。同时具有位置超类参数和位置参数意味着超类构造函数中存在与超类构造函数中的相同参数关联的两个值，因此不允许这样做。

示例

#

以下代码会生成此诊断信息，因为构造函数 B.new 使用超类参数将必需位置参数之一传递给 A 中的超类构造函数，但在超类构造函数调用中显式传递另一个参数：

dart
class A {
  A(int x, int y);
}

class B extends A {
  B(int x, super.y) : super(x);
}

常规修复

#

如果所有位置参数都可以是超类参数，则将普通位置参数转换为超类参数：

dart
class A {
  A(int x, int y);
}

class B extends A {
  B(super.x, super.y);
}

如果某些位置参数不能是超类参数，则将超类参数转换为普通参数：

dart
class A {
  A(int x, int y);
}

class B extends A {
  B(int x, int y) : super(x, y);
}

prefix_collides_with_top_level_member

#

名称 '{0}' 已用作导入前缀，不能用于命名顶级元素。

说明

#

当名称在同一个库中同时用作导入前缀和顶级声明的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 同时用作导入前缀和函数的名称：

dart
import 'dart:math' as f;

int f() => f.min(0, 1);

常规修复

#

如果您想将该名称用于导入前缀，则重命名顶级声明：

dart
import 'dart:math' as f;

int g() => f.min(0, 1);

如果您想将该名称用于顶级声明，则重命名导入前缀：

dart
import 'dart:math' as math;

int f() => math.min(0, 1);

prefix_identifier_not_followed_by_dot

#

名称 '{0}' 指的是导入前缀，因此必须后跟 '.'。

说明

#

当导入前缀本身使用，而不访问与前缀关联的库中声明的任何名称时，分析器会生成此诊断信息。前缀不是变量，因此不能用作值。

示例

#

以下代码会生成此诊断信息，因为前缀 math 被用作变量：

dart
import 'dart:math' as math;

void f() {
  print(math);
}

常规修复

#

如果代码不完整，则引用与前缀关联的库中的某个内容：

dart
import 'dart:math' as math;

void f() {
  print(math.pi);
}

如果名称错误，则更正名称。

prefix_shadowed_by_local_declaration

#

前缀 '{0}' 不能在此处使用，因为它被局部声明遮蔽了。

说明

#

当在导入前缀不可见的情况下使用导入前缀时，分析器会生成此诊断信息，因为它被局部声明遮蔽了。

示例

#

以下代码会生成此诊断信息，因为前缀 a 用于访问类 Future ，但不可见，因为它被参数 a 遮蔽了：

dart
import 'dart:async' as a;

a.Future? f(int a) {
  a.Future? x;
  return x;
}

常规修复

#

重命名前缀：

dart
import 'dart:async' as p;

p.Future? f(int a) {
  p.Future? x;
  return x;
}

或者重命名局部变量：

dart
import 'dart:async' as a;

a.Future? f(int p) {
  a.Future? x;
  return x;
}

private_collision_in_mixin_application

#

由 '{1}' 定义的私有名称 '{0}' 与由 '{2}' 定义的相同名称冲突。

说明

#

当定义了相同私有成员的两个 mixin 在除定义 mixin 的库之外的单个类中一起使用时，分析器会生成此诊断信息。

示例

#

给定一个包含以下代码的文件 a.dart ：

dart
mixin A {
  void _foo() {}
}

mixin B {
  void _foo() {}
}

以下代码会生成此诊断信息，因为 mixin A 和 B 都定义了方法 _foo ：

dart
import 'a.dart';

class C extends Object with A, B {}

常规修复

#

如果您不需要这两个 mixin，则从 with 子句中删除其中一个：

dart
import 'a.dart';

class C extends Object with A, B {}

如果您需要这两个 mixin，则重命名两个 mixin 中的一个的冲突成员。

private_optional_parameter

#

命名参数不能以下划线开头。

说明

#

当命名参数的名称以下划线开头时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为命名参数 _x 以下划线开头：

dart
class C {
  void m({int _x = 0}) {}
}

常规修复

#

重命名参数，使其不以下划线开头：

dart
class C {
  void m({int x = 0}) {}
}

private_setter

#

setter '{0}' 是私有的，不能在声明它的库之外访问。

说明

#

当在私有 setter 不可見的库中使用私有 setter 时，分析器会生成此诊断信息。

示例

#

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

dart
class A {
  static int _f = 0;
}

以下代码会生成此诊断信息，因为它引用了私有 setter _f ，即使该 setter 不可见：

dart
import 'a.dart';

void f() {
  A._f = 0;
}

常规修复

#

如果您能够使 setter 公开，则这样做：

dart
class A {
  static int f = 0;
}

如果您无法使 setter 公开，则找到实现代码的不同方法。

read_potentially_unassigned_final

#

final 变量 '{0}' 无法读取，因为它在此处可能未赋值。

说明

#

当未在声明位置初始化的 final 局部变量在编译器无法证明在引用之前始终初始化该变量的点被读取时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 final 局部变量 x 在可能尚未初始化时被读取（在第 3 行）：

dart
int f() {
  final int x;
  return x;
}

常规修复

#

确保在读取变量之前对其进行了初始化：

dart
int f(bool b) {
  final int x;
  if (b) {
    x = 0;
  } else {
    x = 1;
  }
  return x;
}

record_literal_one_positional_no_trailing_comma

#

具有恰好一个位置字段的记录字面量需要尾随逗号。

说明

#

当具有单个位置字段的记录字面量在字段后没有尾随逗号时，分析器会生成此诊断信息。

说明

#

当将 null 传递给构造函数 Future.value 或方法 Completer.complete 时，分析器会生成此诊断信息，而用于创建实例的类型参数是非空的。即使类型系统无法表达此限制，传递 null 也会导致运行时异常。

示例

#

以下代码会生成此诊断信息，因为即使类型参数是非空类型 String ， null 也正在传递给构造函数 Future.value ：

dart
Future<String> f() {
  return Future.value(null);
}

常规修复

#

传递非空值：

dart
Future<String> f() {
  return Future.value('');
}

null_check_always_fails

#

此空检查将始终引发异常，因为表达式将始终计算为 'null'。

说明

#

当在值只能为 null 的表达式上使用空检查运算符 (!) 时，分析器会生成此诊断信息。在这种情况下，运算符始终会引发异常，这可能不是预期的行为。

示例

#

以下代码会生成此诊断信息，因为函数 g 将始终返回 null ，这意味着 f 中的空检查将始终抛出：

dart
void f() {
  g()!;
}

Null g() => null;

常规修复

#

如果您打算始终引发异常，则用显式的 throw 表达式替换空检查，以使意图更清晰：

dart
void f() {
  g();
  throw TypeError();
}

Null g() => null;

obsolete_colon_for_default_value

#

不再支持使用冒号作为默认值之前的分隔符。

说明

#

当冒号（ : ）用作可选命名参数的默认值之前的分隔符时，分析器会生成此诊断信息。虽然此语法曾经被允许，但它已被删除，建议使用等号（ = ）。

示例

#

以下代码会生成此诊断信息，因为在可选参数 i 的默认值之前使用了冒号：

dart
void f({int i : 0}) {}

常规修复

#

将冒号替换为等号：

dart
void f({int i = 0}) {}

on_repeated

#

类型 '{0}' 只能在超类约束中包含一次。

说明

#

当在 mixin 的超类约束中多次列出相同的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 在 M 的超类约束中出现了两次：

dart
mixin M on A, A {
}

class A {}
class B {}

常规修复

#

如果应在超类约束中包含不同的类型，则将其中一个出现替换为其他类型：

dart
mixin M on A, B {
}

class A {}
class B {}

如果不需要其他类型，则删除重复的类型名称：

dart
mixin M on A {
}

class A {}
class B {}

optional_parameter_in_operator

#

定义运算符时不允许使用可选参数。

说明

#

当运算符声明中的一个或多个参数是可选参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为参数 other 是可选参数：

dart
class C {
  C operator +([C? other]) => this;
}

常规修复

#

使所有参数都是必需的参数：

dart
class C {
  C operator +(C other) => this;
}

override_on_non_overriding_member

#

该字段没有覆盖继承的 getter 或 setter。

该 getter 没有覆盖继承的 getter。

该方法没有覆盖继承的方法。

该 setter 没有覆盖继承的 setter。

说明

#

当类的成员用 @override 注解注释，但该成员未在类的任何超类型中声明时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 未在 C 的任何超类型中声明：

dart
class C {
  @override
  String m() => '';
}

常规修复

#

如果该成员旨在覆盖具有不同名称的成员，则将其更新为具有相同的名称：

dart
class C {
  @override
  String toString() => '';
}

如果该成员旨在覆盖从超类中删除的成员，则考虑从子类中删除该成员。

如果该成员不能被删除，则删除注解。

packed_annotation

#

结构体最多只能有一个 'Packed' 注解。

说明

#

当 Struct 的子类具有多个 Packed 注解时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为类 C 是 Struct 的子类，并且有两个 Packed 注解：

dart
import 'dart:ffi';

@Packed(1)
@Packed(1)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

常规修复

#

删除除一个注解之外的所有注解：

dart
import 'dart:ffi';

@Packed(1)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

packed_annotation_alignment

#

仅支持打包到 1、2、4、8 和 16 字节。

说明

#

当 Packed 注解的参数不是允许的值之一（1、2、4、8 或 16）时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为 Packed 注解（ 3 ）的参数不是允许的值之一：

dart
import 'dart:ffi';

@Packed(3)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

常规修复

#

将对齐更改为允许的值之一：

dart
import 'dart:ffi';

@Packed(4)
final class C extends Struct {
  external Pointer<Uint8> notEmpty;
}

part_of_different_library

#

预期此库是 '{0}' 的一部分，而不是 '{1}'。

说明

#

当库尝试将文件作为自身的一部分包含在内，而另一个文件是不同库的一部分时，分析器会生成此诊断信息。

示例

#

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

dart
part of 'library.dart';

以下代码（在除 library.dart 之外的任何文件中）会生成此诊断信息，因为它尝试将 part.dart 作为自身的一部分包含在内，而 part.dart 是不同库的一部分：

dart
part 'package:a/part.dart';

常规修复

#

如果库应该使用不同的文件作为一部分，则将部分指令中的 URI 更改为其他文件的 URI。

如果 部分文件 应该是此库的一部分，则将部分指令中的 URI（或库名）更新为正确库的 URI（或名称）。

part_of_non_part

#

包含的部分 '{0}' 必须有 part-of 指令。

说明

#

当找到部分指令，并且引用的文件没有 part-of 指令时，分析器会生成此诊断信息。

示例

#

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

dart
class A {}

以下代码会生成此诊断信息，因为 a.dart 不包含 part-of 指令：

dart
part 'a.dart';

常规修复

#

如果引用的文件旨在作为另一个库的一部分，则向该文件添加 part-of 指令：

dart
part of 'test.dart';

class A {}

如果引用的文件旨在作为库，则将部分指令替换为导入指令：

dart
import 'a.dart';

part_of_unnamed_library

#

库未命名。在 part-of 指令中，预期的是 URI，而不是库名 '{0}'。

说明

#

当没有 library 指令（因此没有名称）的库包含 part 指令，并且 部分文件 中的 part of 指令使用名称来指定它是哪个库的一部分时，分析器会生成此诊断信息。

示例

#

给定一个名为 part_file.dart 的 部分文件 ，其中包含以下代码：

dart
part of lib;

以下代码会生成此诊断信息，因为包含 部分文件 的库没有名称，即使 部分文件 使用名称来指定它是哪个库的一部分：

dart
part 'part_file.dart';

常规修复

#

更改 部分文件 中的 part of 指令，以通过 URI 指定其库：

dart
part of 'test.dart';

path_does_not_exist

#

路径 '{0}' 不存在。

说明

#

当依赖项的 path 键引用不存在的目录时，分析器会生成此诊断信息。

示例

#

假设目录 doesNotExist 不存在，则以下代码会生成此诊断信息，因为它被列为包的路径：

yaml
name: example
dependencies:
  local_package:
    path: doesNotExist

常规修复

#

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

如果路径不正确，则将路径更改为与包根目录的路径匹配。

path_not_posix

#

路径 '{0}' 不是 POSIX 样式路径。

说明

#

当依赖项的 path 键的值是字符串，但不是 POSIX 样式路径时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 path 键后面的路径是 Windows 路径：

yaml
name: example
dependencies:
  local_package:
    path: E:\local_package

常规修复

#

将路径转换为 POSIX 路径。

path_pubspec_does_not_exist

#

目录 '{0}' 不包含 pubspec。

说明

#

当依赖项的 path 键引用不包含 pubspec.yaml 文件的目录时，分析器会生成此诊断信息。

示例

#

假设目录 local_package 不包含文件 pubspec.yaml ，则以下代码会生成此诊断信息，因为它被列为包的路径：

yaml
name: example
dependencies:
  local_package:
    path: local_package

常规修复

#

如果路径旨在作为包的根目录，则在目录中添加 pubspec.yaml 文件：

yaml
name: local_package

如果路径错误，则将其替换为正确的路径。

pattern_assignment_not_local_variable

#

只有局部变量才能在模式赋值中赋值。

说明

#

当模式赋值将值赋值给局部变量以外的任何内容时，分析器会生成此诊断信息。模式不能赋值给字段或顶级变量。

示例

#

如果使用模式解构时代码更简洁，则重写代码以在模式声明中将值赋值给局部变量，单独赋值非局部变量：

dart
class C {
  var x = 0;

  void f((int, int) r) {
    (x, _) = r;
  }
}

常规修复

#

如果使用模式赋值时代码更简洁，则重写代码以将值赋值给局部变量，单独赋值非局部变量：

dart
class C {
  var x = 0;

  void f((int, int) r) {
    var (a, _) = r;
    x = a;
  }
}

如果不用模式赋值时代码更简洁，则重写代码以不使用模式赋值：

dart
class C {
  var x = 0;

  void f((int, int) r) {
    x = r.$1;
  }
}

pattern_constant_from_deferred_library

#

来自延迟加载库的常量值不能用于模式中。

说明

#

当模式包含在不同库中声明的值，并且该库使用延迟导入导入时，分析器会生成此诊断信息。

说明

#

当构造函数标记为 const ，但重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

redirect_to_type_alias_expands_to_type_parameter

#

重定向构造函数不能重定向到扩展为类型参数的类型别名。

说明

#

当重定向工厂构造函数重定向到类型别名，并且类型别名扩展为类型别名的类型参数之一时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为对 B<A> 的重定向是到值为 T 的类型别名，即使该值应为 A ：

dart
class A implements C {}

typedef B<T> = T;

abstract class C {
  factory C() = B<A>;
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
class A implements C {}

abstract class C {
  factory C() = A;
}

referenced_before_declaration

#

局部变量 '{0}' 在声明之前不能被引用。

说明

#

当在声明变量之前引用变量时，分析器会生成此诊断信息。在 Dart 中，变量在其声明的块中的任何地方都是可见的，但只能在其声明之后才能被引用。

分析器还会生成上下文消息，指示声明的位置。

示例

#

以下代码会生成此诊断信息，因为 i 在声明之前被使用：

dart
void f() {
  print(i);
  int i = 5;
}

常规修复

#

如果您打算引用局部变量，请将声明移动到第一次引用之前：

dart
void f() {
  int i = 5;
  print(i);
}

如果您打算引用外部作用域中的名称，例如参数、实例字段或顶级变量，则重命名局部声明，使其不隐藏外部变量。

dart
void f(int i) {
  print(i);
  int x = 5;
  print(x);
}

refutable_pattern_in_irrefutable_context

#

不可反驳的模式不能在可反驳的上下文中使用。

说明

#

当在只允许 不可反驳的模式 的上下文中使用 可反驳的模式 时，分析器会生成此诊断信息。

不允许的可反驳模式是：

  • 逻辑或
  • 关系
  • 空检查
  • 常量

检查的上下文是：

  • 基于模式的变量声明
  • 基于模式的 for 循环
  • 左侧有模式的赋值

示例

#

以下代码会生成此诊断信息，因为空检查模式（它是一个可反驳的模式）位于基于模式的变量声明中，基于模式的变量声明不允许可反驳模式：

dart
void f(int? x) {
  var (_?) = x;
}

常规修复

#

重写代码，使其不在不可反驳的上下文中使用可反驳的模式。

relational_pattern_operand_type_not_assignable

#

常量表达式类型 '{0}' 无法赋值给 '{2}' 运算符的参数类型 '{1}'。

说明

#

当关系模式的操作数的类型无法赋值给将调用的运算符的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式（ 0 ）中的操作数是 int ，但 C 中定义的 > 运算符期望一个类型为 C 的对象：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > 0:
      print('positive');
  }
}

常规修复

#

如果 switch 使用正确的值，则更改 case 以将值与正确的对象类型进行比较：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > const C():
      print('positive');
  }
}

如果 switch 使用错误的值，则更改用于计算正在匹配的值的表达式：

dart
class C {
  const C();

  bool operator >(C other) => true;

  int get toInt => 0;
}

void f(C c) {
  switch (c.toInt) {
    case > 0:
      print('positive');
  }
}

relational_pattern_operator_return_type_not_assignable_to_bool

#

关系模式中使用的运算符的返回类型必须可赋值为 'bool'。

说明

#

当关系模式引用一个不产生类型为 bool 的值的运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式 > c2 中使用的运算符 > 返回类型为 int 的值而不是 bool ：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

常规修复

#

如果有其他应使用的运算符，则更改运算符：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case < c2) {}
}

如果运算符应返回 bool ，则更新运算符的声明：

dart
class C {
  const C();

  bool operator >(C c) => true;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

rest_element_in_map_pattern

#

映射模式不能包含 rest 模式。

说明

#

当映射模式包含 rest 模式时，分析器会生成此诊断信息。映射模式匹配键多于模式中显式给出的键的映射（只要给定的键匹配），因此 rest 模式是不必要的。

示例

#

以下代码会生成此诊断信息，因为映射模式包含 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _, ...}) {}
}

常规修复

#

删除 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _}) {}
}

rethrow_outside_catch

#

rethrow 必须位于 catch 子句中。

说明

#

当 rethrow 语句位于 catch 子句之外时，分析器会生成此诊断信息。 rethrow 语句用于再次抛出捕获的异常，但在 catch 子句之外没有捕获的异常。

示例

#

以下代码会生成此诊断信息，因为 rethrow 语句位于 catch 子句之外：

dart
void f() {
  rethrow;
}

常规修复

#

如果您尝试重新抛出异常，则将 rethrow 语句包装在 catch 子句中：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    rethrow;
  }
}

如果您尝试抛出一个新的异常，则将 rethrow 语句替换为 throw 表达式：

dart
void f() {
  throw UnsupportedError('Not yet implemented');
}

return_in_generative_constructor

#

构造函数不能返回值。

说明

#

当生成式构造函数包含一个指定要返回的值的 return 语句时，分析器会生成此诊断信息。生成式构造函数始终返回已创建的对象，因此不能返回不同的对象。

示例

#

以下代码会生成此诊断信息，因为 return 语句有一个表达式：

dart
class C {
  C() {
    return this;
  }
}

常规修复

#

如果构造函数应创建一个新的实例，则删除 return 语句或表达式：

dart
class C {
  C();
}

如果构造函数不应创建新的实例，则将其转换为工厂构造函数：

dart
class C {
  factory C() {
    return _instance;
  }

  static C _instance = C._();

  C._();
}

return_in_generator

#

不能从使用 'async*' 或 'sync*' 修饰符的生成器函数返回值。

说明

#

当生成器函数（其主体用 async* 或 sync* 标记）使用 return 语句返回值或由于使用 => 而隐式返回值时，分析器会生成此诊断信息。在任何这些情况下，它们都应使用 yield 代替 return 。

示例

#

以下代码会生成此诊断信息，因为方法 f 是生成器，并且正在使用 return 返回值：

dart
Iterable<int> f() sync* {
  return 3;
}

以下代码会生成此诊断信息，因为函数 f 是生成器，并且正在隐式返回值：

dart
Stream<int> f() async* => 3;

常规修复

#

如果函数对函数体使用 => ，则将其转换为块函数体，并使用 yield 返回值：

dart
Stream<int> f() async* {
  yield 3;
}

如果该方法旨在作为生成器，则使用 yield 返回值：

dart
Iterable<int> f() sync* {
  yield 3;
}

如果该方法不旨在作为生成器，则从主体中删除修饰符（或者如果您要返回 future，则使用 async ）：

dart
int f() {
  return 3;
}

return_of_do_not_store

#

' {0}' 用 'doNotStore' 注释，除非 '{1}' 也被注释，否则不应返回。

说明

#

当用 doNotStore 注解注释的值从没有相同注解的方法、getter 或函数中返回时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为不应该存储调用 f 的结果，但函数 g 没有被注释以保留该语义：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => f();

常规修复

#

如果不应该存储的值是正确的返回值，则使用 doNotStore 注解标记该函数：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

@doNotStore
int g() => f();

否则，从函数中返回不同的值：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => 0;

return_of_invalid_type

#

类型为 '{0}' 的值无法从构造函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从方法 '{2}' 返回，因为它返回类型为 '{1}'。

说明

#

当方法或函数返回的值的类型无法赋值给声明的返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 的返回类型为 String ，但它返回的是 int ：

dart
String f() => 3;

常规修复

#

如果返回类型正确，则用正确类型的返回值替换正在返回的值，可能通过转换现有值：

dart
String f() => 3.toString();

如果该值正确，则更改返回类型以匹配：

dart
int f() => 3;

return_of_invalid_type_from_closure

#

返回类型 '{0}' 无法从 '{1}' 函数返回，这是闭包上下文所需的。

说明

#

当返回表达式的静态类型无法赋值给闭包所需的返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 被定义为返回 String 的函数，但分配给它的闭包返回 int ：

dart
String Function(String) f = (s) => 3;

常规修复

#

如果返回类型正确，则用正确类型的返回值替换正在返回的值，可能通过转换现有值：

dart
String Function(String) f = (s) => 3.toString();

return_without_value

#

'return' 后缺少返回值。

说明

#

当分析器在声明了返回类型的函数中找到没有表达式的 return 语句时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为预期函数 f 返回 int ，但没有返回值：

dart
int f() {
  return;
}

常规修复

#

添加一个计算要返回的值的表达式：

dart
int f() {
  return 0;
}

sdk_version_async_exported_from_core

#

类 '{0}' 直到版本 2.1 才从 'dart:core' 导出，但此代码需要能够在早期版本上运行。

说明

#

当库在其 SDK 约束的下限小于 2.1.0 的代码中引用类 Future 或 Stream 但没有导入 dart:async 时，分析器会生成此诊断信息。在早期版本中，这些类未在 dart:core 中定义，因此需要导入。

示例

#

这是一个定义了 SDK 约束（下限小于 2.1.0）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.0.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
void f(Future f) {}

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许引用这些类：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

如果您需要支持旧版本的 SDK，则导入 dart:async 库。

dart
import 'dart:async';

void f(Future f) {}

sdk_version_as_expression_in_const_context

#

在常量表达式中使用 as 表达式直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内的 as 表达式时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用 as 表达式，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
const num n = 3;
const int i = n as int;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该表达式：

yaml
environment:
  sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 as 表达式，或者更改代码以使 as 表达式不在 常量上下文 中：

dart
num x = 3;
int y = x as int;

sdk_version_bool_operator_in_const_context

#

在常量上下文中对 'bool' 操作数使用运算符 '{0}' 直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内对类 bool 使用 & 、 | 或 ^ 运算符时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用这些运算符，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
const bool a = true;
const bool b = false;
const bool c = a & b;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用这些运算符：

yaml
environment:
 sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用这些运算符，或者更改代码以使表达式不在 常量上下文 中：

dart
const bool a = true;
const bool b = false;
bool c = a & b;

sdk_version_constructor_tearoffs

#

分离构造函数需要 'constructor-tearoffs' 语言特性。

说明

#

当在 SDK 约束的下限小于 2.15 的代码中找到构造函数分离时，分析器会生成此诊断信息。在早期版本中不支持构造函数分离，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.15）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.9.0 <2.15.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
var setConstructor = Set.identity;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该运算符：

yaml
environment:
  sdk: '>=2.15.0 <2.16.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用构造函数分离：

dart
var setConstructor = () => Set.identity();

sdk_version_eq_eq_operator_in_const_context

#

在常量上下文中对非原始类型使用运算符 '==' 直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内对非原始类型使用运算符 == 时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用此运算符，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
class C {}
const C a = null;
const C b = null;
const bool same = a == b;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该运算符：

yaml
environment:
  sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 == 运算符，或者更改代码以使表达式不在 常量上下文 中：

dart
class C {}
const C a = null;
const C b = null;
bool same = a == b;

sdk_version_extension_methods

#

扩展方法直到版本 2.6.0 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.6.0 的代码中找到扩展声明或扩展重写时，分析器会生成此诊断信息。在早期版本中不支持使用扩展，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.6.0）的 pubspec 示例：

yaml
environment:
 sdk: '>=2.4.0 <2.7.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
extension E on String {
  void sayHello() {
    print('Hello $this');
  }
}

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该语法：

yaml
environment:
  sdk: '>=2.6.0 <2.7.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用扩展。最常见的方法是将扩展的成员重写为顶级函数（或方法），并将绑定到 this 的值作为参数传入：

dart
void sayHello(String s) {
  print('Hello $s');
}

sdk_version_gt_gt_gt_operator

#

运算符 '>>>' 直到版本 2.14.0 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.14.0 的代码中使用运算符 >>> 时，分析器会生成此诊断信息。在早期版本中不支持此运算符，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.14.0）的 pubspec 示例：

yaml
environment:
 sdk: '>=2.0.0 <2.15.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
int x = 3 >>> 4;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该运算符：

yaml
environment:
  sdk: '>=2.14.0 <2.15.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 >>> 运算符：

dart
int x = logicalShiftRight(3, 4);

int logicalShiftRight(int leftOperand, int rightOperand) {
  int divisor = 1 << rightOperand;
  if (divisor == 0) {
    return 0;
  }
  return leftOperand ~/ divisor;
}

sdk_version_is_expression_in_const_context

#

在常量上下文中使用 is 表达式直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内的 is 表达式时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用 is 表达式，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
const Object x = 4;
const y = x is int ? 0 : 1;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该表达式：

yaml
environment:
  sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 is 表达式，或者更改代码以使表达式不在 常量上下文 中：

如果该值正确，则更改返回类型以匹配：

dart
int f() => 3;

return_of_invalid_type_from_closure

#

返回类型 '{0}' 无法从 '{1}' 函数返回，这是闭包上下文所需的。

说明

#

当返回表达式的静态类型无法赋值给闭包所需的返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 被定义为返回 String 的函数，但分配给它的闭包返回 int ：

dart
String Function(String) f = (s) => 3;

常规修复

#

如果返回类型正确，则用正确类型的返回值替换正在返回的值，可能通过转换现有值：

dart
String Function(String) f = (s) => 3.toString();

return_without_value

#

'return' 后缺少返回值。

说明

#

当分析器在声明了返回类型的函数中找到没有表达式的 return 语句时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 预期返回 int ，但没有返回值：

dart
int f() {
  return;
}

常规修复

#

添加一个计算要返回的值的表达式：

dart
int f() {
  return 0;
}

sdk_version_async_exported_from_core

#

类 '{0}' 直到版本 2.1 才从 'dart:core' 导出，但此代码需要能够在早期版本上运行。

说明

#

当库在其 SDK 约束的下限小于 2.1.0 的代码中引用类 Future 或 Stream 但没有导入 dart:async 时，分析器会生成此诊断信息。在早期版本中，这些类未在 dart:core 中定义，因此需要导入。

示例

#

这是一个定义了 SDK 约束（下限小于 2.1.0）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.0.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
void f(Future f) {}

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许引用这些类：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

如果您需要支持旧版本的 SDK，则导入 dart:async 库。

dart
import 'dart:async';

void f(Future f) {}

sdk_version_as_expression_in_const_context

#

在常量表达式中使用 as 表达式直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内的 as 表达式时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用 as 表达式，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
const num n = 3;
const int i = n as int;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该表达式：

yaml
environment:
  sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 as 表达式，或者更改代码以使 as 表达式不在 常量上下文 中：

dart
num x = 3;
int y = x as int;

sdk_version_bool_operator_in_const_context

#

在常量上下文中对 'bool' 操作数使用运算符 '{0}' 直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内对类 bool 使用 & 、 | 或 ^ 运算符时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用这些运算符，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
const bool a = true;
const bool b = false;
const bool c = a & b;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用这些运算符：

yaml
environment:
 sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用这些运算符，或者更改代码以使表达式不在 常量上下文 中：

dart
const bool a = true;
const bool b = false;
bool c = a & b;

sdk_version_constructor_tearoffs

#

分离构造函数需要 'constructor-tearoffs' 语言特性。

说明

#

当在 SDK 约束的下限小于 2.15 的代码中找到构造函数分离时，分析器会生成此诊断信息。在早期版本中不支持构造函数分离，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.15）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.9.0 <2.15.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
var setConstructor = Set.identity;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该运算符：

yaml
environment:
  sdk: '>=2.15.0 <2.16.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用构造函数分离：

dart
var setConstructor = () => Set.identity();

sdk_version_eq_eq_operator_in_const_context

#

在常量上下文中对非原始类型使用运算符 '==' 直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内对非原始类型使用运算符 == 时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用此运算符，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
class C {}
const C a = null;
const C b = null;
const bool same = a == b;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该运算符：

yaml
environment:
  sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 == 运算符，或者更改代码以使表达式不在 常量上下文 中：

dart
class C {}
const C a = null;
const C b = null;
bool same = a == b;

sdk_version_extension_methods

#

扩展方法直到版本 2.6.0 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.6.0 的代码中找到扩展声明或扩展重写时，分析器会生成此诊断信息。在早期版本中不支持使用扩展，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.6.0）的 pubspec 示例：

yaml
environment:
 sdk: '>=2.4.0 <2.7.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
extension E on String {
  void sayHello() {
    print('Hello $this');
  }
}

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该语法：

yaml
environment:
  sdk: '>=2.6.0 <2.7.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用扩展。最常见的方法是将扩展的成员重写为顶级函数（或方法），并将绑定到 this 的值作为参数传入：

dart
void sayHello(String s) {
  print('Hello $s');
}

sdk_version_gt_gt_gt_operator

#

运算符 '>>>' 直到版本 2.14.0 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.14.0 的代码中使用运算符 >>> 时，分析器会生成此诊断信息。在早期版本中不支持此运算符，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.14.0）的 pubspec 示例：

yaml
environment:
 sdk: '>=2.0.0 <2.15.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
int x = 3 >>> 4;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该运算符：

yaml
environment:
  sdk: '>=2.14.0 <2.15.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 >>> 运算符：

dart
int x = logicalShiftRight(3, 4);

int logicalShiftRight(int leftOperand, int rightOperand) {
  int divisor = 1 << rightOperand;
  if (divisor == 0) {
    return 0;
  }
  return leftOperand ~/ divisor;
}

sdk_version_is_expression_in_const_context

#

在常量上下文中使用 is 表达式直到版本 2.3.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.2 的代码中，在 常量上下文 内的 is 表达式时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 中使用 is 表达式，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.2）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
const Object x = 4;
const y = x is int ? 0 : 1;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该表达式：

yaml
environment:
  sdk: '>=2.3.2 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用 is 运算符，或者如果这不可行，则更改代码以使 is 表达式不在 常量上下文 中：

dart
const Object x = 4;
var y = x is int ? 0 : 1;

sdk_version_never

#

类型 'Never' 直到版本 2.12.0 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.12.0 的代码中找到对类 Never 的引用时，分析器会生成此诊断信息。在早期版本中未定义此类，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.12.0）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.5.0 <2.6.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
Never n;

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该类型：

yaml
environment:
  sdk: '>=2.12.0 <2.13.0'

如果您需要支持旧版本的 SDK，则重写代码以不引用此类：

dart
dynamic x;

sdk_version_set_literal

#

集合字面量直到版本 2.2 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.2.0 的代码中找到集合字面量时，分析器会生成此诊断信息。在早期版本中不支持集合字面量，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.2.0）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.1.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
var s = <int>{};

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该语法：

yaml
environment:
  sdk: '>=2.2.0 <2.4.0'

如果您确实需要支持旧版本的 SDK，则用不使用字面量的代码替换集合字面量：

dart
var s = new Set<int>();

sdk_version_ui_as_code

#

for、if 和展开元素直到版本 2.3.0 才受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.3.0 的代码中找到 for、if 或展开元素时，分析器会生成此诊断信息。在早期版本中不支持使用 for、if 或展开元素，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.3.0）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.2.0 <2.4.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
var digits = [for (int i = 0; i < 10; i++) i];

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该语法：

yaml
environment:
  sdk: '>=2.3.0 <2.4.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用这些元素：

dart
var digits = _initializeDigits();

List<int> _initializeDigits() {
  var digits = <int>[];
  for (int i = 0; i < 10; i++) {
    digits.add(i);
  }
  return digits;
}

sdk_version_ui_as_code_in_const_context

#

if 和展开元素直到版本 2.5.0 才在常量表达式中受支持，但此代码需要能够在早期版本上运行。

说明

#

当在 SDK 约束的下限小于 2.5.0 的代码中，在 常量上下文 内的 if 或展开元素时，分析器会生成此诊断信息。在早期版本中，不支持在 常量上下文 内使用 if 或展开元素，因此此代码将无法针对早期版本的 SDK 运行。

示例

#

这是一个定义了 SDK 约束（下限小于 2.5.0）的 pubspec 示例：

yaml
environment:
  sdk: '>=2.4.0 <2.6.0'

在具有该 pubspec 的包中，以下代码会生成此诊断信息：

dart
const a = [1, 2];
const b = [...a];

常规修复

#

如果您不需要支持旧版本的 SDK，则可以增加 SDK 约束以允许使用该语法：

yaml
environment:
  sdk: '>=2.5.0 <2.6.0'

如果您需要支持旧版本的 SDK，则重写代码以不使用这些元素：

dart
const a = [1, 2];
const b = [1, 2];

如果这不可行，则更改代码以使元素不在 常量上下文 中：

dart
const a = [1, 2];
var b = [...a];

set_element_type_not_assignable

#

元素类型 '{0}' 无法赋值给集合类型 '{1}'。

说明

#

当集合字面量中的元素的类型无法赋值给集合的元素类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字符串字面量 '0' 的类型是 String ，它无法赋值给 int （集合的元素类型）：

dart
var s = <int>{'0'};

常规修复

#

如果集合字面量的元素类型错误，则更改集合的元素类型：

dart
var s = <String>{'0'};

如果元素的类型错误，则更改元素：

dart
var s = <int>{'0'.length};

shared_deferred_prefix

#

延迟导入的前缀不能用于其他导入指令中。

说明

#

当延迟导入中的前缀也用作其他导入（无论是延迟导入还是非延迟导入）中的前缀时，分析器会生成此诊断信息。延迟导入中的前缀不能与其他导入共享，因为前缀用于加载导入的库。

示例

#

以下代码会生成此诊断信息，因为前缀 x 用作延迟导入的前缀，也用于另一个导入：

dart
import 'dart:math' deferred as x;
import 'dart:convert' as x;

var y = x.json.encode(x.min(0, 1));

常规修复

#

如果您能对延迟导入使用不同的名称，则这样做：

dart
import 'dart:math' deferred as math;
import 'dart:convert' as x;

var y = x.json.encode(math.min(0, 1));

如果您能对其他导入使用不同的名称，则这样做：

dart
import 'dart:math' deferred as x;
import 'dart:convert' as convert;

var y = convert.json.encode(x.min(0, 1));

size_annotation_dimensions

#

'Array' 必须有一个与维度匹配的 'Array' 注解。

说明

#

当 Array 注解中指定的维度数量与字段类型指定的嵌套数组数量不匹配时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 的类型有三个嵌套数组，但在 Array 注解中只给出了两个维度：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8, 8)
  external Array<Array<Array<Uint8>>> a0;
}

常规修复

#

如果字段的类型正确，则修复注解使其具有所需的维度数量：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8, 8, 4)
  external Array<Array<Array<Uint8>>> a0;
}

如果字段的类型错误，则修复字段的类型：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8, 8)
  external Array<Array<Uint8>> a0;
}

static_access_to_instance_member

#

不能使用静态访问来访问实例成员 '{0}'。

说明

#

当使用类名访问实例字段时，分析器会生成此诊断信息。实例字段不存在于类中；它们只存在于类的实例中。

示例

#

以下代码会生成此诊断信息，因为 x 是实例字段：

dart
class C {
  static int a = 0;

  int b = 0;
}

int f() => C.b;

常规修复

#

如果您打算访问静态字段，则将字段的名称更改为现有的静态字段：

dart
class C {
  static int a = 0;

  int b = 0;
}

int f() => C.a;

如果您打算访问实例字段，则使用类的实例来访问该字段：

dart
class C {
  static int a = 0;

  int b = 0;
}

int f(C c) => c.b;

subtype_of_base_or_final_is_not_base_final_or_sealed

#

mixin '{0}' 必须是 'base'，因为超类型 '{1}' 是 'base'。

mixin '{0}' 必须是 'base'，因为超类型 '{1}' 是 'final'。

类型 '{0}' 必须是 'base'、'final' 或 'sealed'，因为超类型 '{1}' 是 'base'。

类型 '{0}' 必须是 'base'、'final' 或 'sealed'，因为超类型 '{1}' 是 'final'。

说明

#

当类或 mixin 具有直接或间接超类型为 base 或 final ，但类或 mixin 本身未标记为 base 、 final 或 sealed 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 B 是 A 的子类型，而 A 是 base 类，但 B 既不是 base 、 final 也不是 sealed ：

dart
base class A {}
class B extends A {}

常规修复

#

向类或 mixin 声明中添加 base 、 final 或 sealed ：

dart
base class A {}
final class B extends A {}

subtype_of_deferred_class

#

类和 mixin 不能实现延迟加载类。

类不能扩展延迟加载类。

类不能混合延迟加载类。

说明

#

当类型（类或 mixin）是使用延迟导入导入的库中的类的子类型时，分析器会生成此诊断信息。类型的超类型必须与类型同时编译，而延迟加载库中的类直到加载库后才会编译。

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

示例

#

给定一个定义类 A 的文件 a.dart ：

dart
class A {}

以下代码会生成此诊断信息，因为 B 的超类在延迟加载库中声明：

dart
import 'a.dart' deferred as a;

class B extends a.A {}

常规修复

#

如果您需要创建延迟加载库中类型的子类型，则删除 deferred 关键字：

dart
import 'a.dart' as a;

class B extends a.A {}

subtype_of_disallowed_type

#

' {0}' 不能用作超类约束。

类和 mixin 不能实现 '{0}'。

类不能扩展 '{0}'。

类不能混合 '{0}'。

说明

#

当在 extends 、 implements 、 with 或 on 子句中使用受限类之一时，分析器会生成此诊断信息。类 bool 、 double 、 FutureOr 、 int 、 Null 、 num 和 String 都以这种方式受到限制，以便进行更有效的实现。

示例

#

以下代码会生成此诊断信息，因为 String 用于 extends 子句中：

dart
class A extends String {}

以下代码会生成此诊断信息，因为 String 用于 implements 子句中：

dart
class B implements String {}

以下代码会生成此诊断信息，因为 String 用于 with 子句中：

dart
class C with String {}

说明

#

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

redirect_to_type_alias_expands_to_type_parameter

#

重定向构造函数不能重定向到扩展为类型参数的类型别名。

说明

#

当重定向工厂构造函数重定向到类型别名，并且类型别名扩展为类型别名的类型参数之一时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为对 B<A> 的重定向是到值为 T 的类型别名，即使该值应为 A ：

dart
class A implements C {}

typedef B<T> = T;

abstract class C {
  factory C() = B<A>;
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
class A implements C {}

abstract class C {
  factory C() = A;
}

referenced_before_declaration

#

局部变量 '{0}' 在声明之前不能被引用。

说明

#

当在声明变量之前引用变量时，分析器会生成此诊断信息。在 Dart 中，变量在其声明的块中的任何地方都是可见的，但只能在其声明之后才能被引用。

分析器还会生成上下文消息，指示声明的位置。

示例

#

以下代码会生成此诊断信息，因为 i 在声明之前被使用：

dart
void f() {
  print(i);
  int i = 5;
}

常规修复

#

如果您打算引用局部变量，请将声明移动到第一次引用之前：

dart
void f() {
  int i = 5;
  print(i);
}

如果您打算引用外部作用域中的名称，例如参数、实例字段或顶级变量，则重命名局部声明，使其不隐藏外部变量。

dart
void f(int i) {
  print(i);
  int x = 5;
  print(x);
}

refutable_pattern_in_irrefutable_context

#

可反驳的模式不能在不可反驳的上下文中使用。

说明

#

当在只允许 不可反驳的模式 的上下文中使用 可反驳的模式 时，分析器会生成此诊断信息。

不允许的可反驳模式是：

  • 逻辑或
  • 关系
  • 空检查
  • 常量

检查的上下文是：

  • 基于模式的变量声明
  • 基于模式的 for 循环
  • 左侧有模式的赋值

示例

#

以下代码会生成此诊断信息，因为空检查模式（它是一个可反驳的模式）位于基于模式的变量声明中，基于模式的变量声明不允许可反驳模式：

dart
void f(int? x) {
  var (_?) = x;
}

常规修复

#

重写代码，使其不在不可反驳的上下文中使用可反驳的模式。

relational_pattern_operand_type_not_assignable

#

常量表达式类型 '{0}' 无法赋值给 '{2}' 运算符的参数类型 '{1}'。

说明

#

当关系模式的操作数的类型无法赋值给将调用的运算符的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式（ 0 ）中的操作数是 int ，但 C 中定义的 > 运算符期望一个类型为 C 的对象：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > 0:
      print('positive');
  }
}

常规修复

#

如果 switch 使用正确的值，则更改 case 以将值与正确的对象类型进行比较：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > const C():
      print('positive');
  }
}

如果 switch 使用错误的值，则更改用于计算正在匹配的值的表达式：

dart
class C {
  const C();

  bool operator >(C other) => true;

  int get toInt => 0;
}

void f(C c) {
  switch (c.toInt) {
    case > 0:
      print('positive');
  }
}

relational_pattern_operator_return_type_not_assignable_to_bool

#

关系模式中使用的运算符的返回类型必须可赋值为 'bool'。

说明

#

当关系模式引用一个不产生类型为 bool 的值的运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式 > c2 中使用的运算符 > 返回类型为 int 的值而不是 bool ：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

常规修复

#

如果有其他应使用的运算符，则更改运算符：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case < c2) {}
}

如果运算符应返回 bool ，则更新运算符的声明：

dart
class C {
  const C();

  bool operator >(C c) => true;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

rest_element_in_map_pattern

#

映射模式不能包含 rest 模式。

说明

#

当映射模式包含 rest 模式时，分析器会生成此诊断信息。映射模式匹配键多于模式中显式给出的键的映射（只要给定的键匹配），因此 rest 模式是不必要的。

示例

#

以下代码会生成此诊断信息，因为映射模式包含 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _, ...}) {}
}

常规修复

#

删除 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _}) {}
}

rethrow_outside_catch

#

rethrow 必须位于 catch 子句中。

说明

#

当 rethrow 语句位于 catch 子句之外时，分析器会生成此诊断信息。 rethrow 语句用于再次抛出捕获的异常，但在 catch 子句之外没有捕获的异常。

示例

#

以下代码会生成此诊断信息，因为 rethrow 语句位于 catch 子句之外：

dart
void f() {
  rethrow;
}

常规修复

#

如果您尝试重新抛出异常，则将 rethrow 语句包装在 catch 子句中：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    rethrow;
  }
}

如果您尝试抛出一个新的异常，则将 rethrow 语句替换为 throw 表达式：

dart
void f() {
  throw UnsupportedError('Not yet implemented');
}

return_in_generative_constructor

#

构造函数不能返回值。

说明

#

当生成式构造函数包含一个指定要返回的值的 return 语句时，分析器会生成此诊断信息。生成式构造函数始终返回已创建的对象，因此不能返回不同的对象。

示例

#

以下代码会生成此诊断信息，因为 return 语句有一个表达式：

dart
class C {
  C() {
    return this;
  }
}

常规修复

#

如果构造函数应创建一个新的实例，则删除 return 语句或表达式：

dart
class C {
  C();
}

如果构造函数不应创建新的实例，则将其转换为工厂构造函数：

dart
class C {
  factory C() {
    return _instance;
  }

  static C _instance = C._();

  C._();
}

return_in_generator

#

不能从使用 'async*' 或 'sync*' 修饰符的生成器函数返回值。

说明

#

当生成器函数（其主体用 async* 或 sync* 标记）使用 return 语句返回值或由于使用 => 而隐式返回值时，分析器会生成此诊断信息。在任何这些情况下，它们都应使用 yield 代替 return 。

示例

#

以下代码会生成此诊断信息，因为方法 f 是生成器，并且正在使用 return 返回值：

dart
Iterable<int> f() sync* {
  return 3;
}

以下代码会生成此诊断信息，因为函数 f 是生成器，并且正在隐式返回值：

dart
Stream<int> f() async* => 3;

常规修复

#

如果函数对函数体使用 => ，则将其转换为块函数体，并使用 yield 返回值：

dart
Stream<int> f() async* {
  yield 3;
}

如果该方法旨在作为生成器，则使用 yield 返回值：

dart
Iterable<int> f() sync* {
  yield 3;
}

如果该方法不旨在作为生成器，则从主体中删除修饰符（或者如果您要返回 future，则使用 async ）：

dart
int f() {
  return 3;
}

return_of_do_not_store

#

' {0}' 用 'doNotStore' 注释，除非 '{1}' 也被注释，否则不应返回。

说明

#

当用 doNotStore 注解注释的值从没有相同注解的方法、getter 或函数中返回时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为不应该存储调用 f 的结果，但函数 g 没有被注释以保留该语义：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => f();

常规修复

#

如果不应该存储的值是正确的返回值，则使用 doNotStore 注解标记该函数：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

@doNotStore
int g() => f();

否则，从函数中返回不同的值：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => 0;

return_of_invalid_type

#

类型为 '{0}' 的值无法从构造函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从方法 '{2}' 返回，因为它返回类型为 '{1}'。

说明

#

当方法或函数返回的值的类型无法赋值给声明的返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 的返回类型为 String ，但它返回的是 int ：

dart
String f() => 3;

常规修复

#

如果返回类型正确，则用正确类型的返回值替换正在返回的值，可能通过转换现有值：

dart
String f() => 3.toString();

redirect_to_non_const_constructor

#

常量重定向构造函数不能重定向到非常量构造函数。

说明

#

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

redirect_to_type_alias_expands_to_type_parameter

#

重定向构造函数不能重定向到扩展为类型参数的类型别名。

说明

#

当重定向工厂构造函数重定向到类型别名，并且类型别名扩展为类型别名的类型参数之一时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为对 B<A> 的重定向是到值为 T 的类型别名，即使该值应为 A ：

dart
class A implements C {}

typedef B<T> = T;

abstract class C {
  factory C() = B<A>;
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
class A implements C {}

abstract class C {
  factory C() = A;
}

referenced_before_declaration

#

局部变量 '{0}' 在声明之前不能被引用。

说明

#

当在声明变量之前引用变量时，分析器会生成此诊断信息。在 Dart 中，变量在其声明的块中的任何地方都是可见的，但只能在其声明之后才能被引用。

分析器还会生成上下文消息，指示声明的位置。

示例

#

以下代码会生成此诊断信息，因为 i 在声明之前被使用：

dart
void f() {
  print(i);
  int i = 5;
}

常规修复

#

如果您打算引用局部变量，请将声明移动到第一次引用之前：

dart
void f() {
  int i = 5;
  print(i);
}

如果您打算引用外部作用域中的名称，例如参数、实例字段或顶级变量，则重命名局部声明，使其不隐藏外部变量。

dart
void f(int i) {
  print(i);
  int x = 5;
  print(x);
}

refutable_pattern_in_irrefutable_context

#

可反驳的模式不能在不可反驳的上下文中使用。

说明

#

当在只允许 不可反驳的模式 的上下文中使用 可反驳的模式 时，分析器会生成此诊断信息。

不允许的可反驳模式是：

  • 逻辑或
  • 关系
  • 空检查
  • 常量

检查的上下文是：

  • 基于模式的变量声明
  • 基于模式的 for 循环
  • 左侧有模式的赋值

示例

#

以下代码会生成此诊断信息，因为空检查模式（它是一个可反驳的模式）位于基于模式的变量声明中，基于模式的变量声明不允许可反驳模式：

dart
void f(int? x) {
  var (_?) = x;
}

常规修复

#

重写代码，使其不在不可反驳的上下文中使用可反驳的模式。

relational_pattern_operand_type_not_assignable

#

常量表达式类型 '{0}' 无法赋值给 '{2}' 运算符的参数类型 '{1}'。

说明

#

当关系模式的操作数的类型无法赋值给将调用的运算符的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式（ 0 ）中的操作数是 int ，但 C 中定义的 > 运算符期望一个类型为 C 的对象：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > 0:
      print('positive');
  }
}

常规修复

#

如果 switch 使用正确的值，则更改 case 以将值与正确的对象类型进行比较：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > const C():
      print('positive');
  }
}

如果 switch 使用错误的值，则更改用于计算正在匹配的值的表达式：

dart
class C {
  const C();

  bool operator >(C other) => true;

  int get toInt => 0;
}

void f(C c) {
  switch (c.toInt) {
    case > 0:
      print('positive');
  }
}

relational_pattern_operator_return_type_not_assignable_to_bool

#

关系模式中使用的运算符的返回类型必须可赋值为 'bool'。

说明

#

当关系模式引用一个不产生类型为 bool 的值的运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式 > c2 中使用的运算符 > 返回类型为 int 的值而不是 bool ：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

常规修复

#

如果有其他应使用的运算符，则更改运算符：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case < c2) {}
}

如果运算符应返回 bool ，则更新运算符的声明：

dart
class C {
  const C();

  bool operator >(C c) => true;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

rest_element_in_map_pattern

#

映射模式不能包含 rest 模式。

说明

#

当映射模式包含 rest 模式时，分析器会生成此诊断信息。映射模式匹配键多于模式中显式给出的键的映射（只要给定的键匹配），因此 rest 模式是不必要的。

示例

#

以下代码会生成此诊断信息，因为映射模式包含 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _, ...}) {}
}

常规修复

#

删除 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _}) {}
}

rethrow_outside_catch

#

rethrow 必须位于 catch 子句中。

说明

#

当 rethrow 语句位于 catch 子句之外时，分析器会生成此诊断信息。 rethrow 语句用于再次抛出捕获的异常，但在 catch 子句之外没有捕获的异常。

示例

#

以下代码会生成此诊断信息，因为 rethrow 语句位于 catch 子句之外：

dart
void f() {
  rethrow;
}

常规修复

#

如果您尝试重新抛出异常，则将 rethrow 语句包装在 catch 子句中：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    rethrow;
  }
}

如果您尝试抛出一个新的异常，则将 rethrow 语句替换为 throw 表达式：

dart
void f() {
  throw UnsupportedError('Not yet implemented');
}

return_in_generative_constructor

#

构造函数不能返回值。

说明

#

当生成式构造函数包含一个指定要返回的值的 return 语句时，分析器会生成此诊断信息。生成式构造函数始终返回已创建的对象，因此不能返回不同的对象。

示例

#

以下代码会生成此诊断信息，因为 return 语句有一个表达式：

dart
class C {
  C() {
    return this;
  }
}

常规修复

#

如果构造函数应创建一个新的实例，则删除 return 语句或表达式：

dart
class C {
  C();
}

如果构造函数不应创建新的实例，则将其转换为工厂构造函数：

dart
class C {
  factory C() {
    return _instance;
  }

  static C _instance = C._();

  C._();
}

return_in_generator

#

不能从使用 'async*' 或 'sync*' 修饰符的生成器函数返回值。

说明

#

当生成器函数（其主体用 async* 或 sync* 标记）使用 return 语句返回值或由于使用 => 而隐式返回值时，分析器会生成此诊断信息。在任何这些情况下，它们都应使用 yield 代替 return 。

示例

#

以下代码会生成此诊断信息，因为方法 f 是生成器，并且正在使用 return 返回值：

dart
Iterable<int> f() sync* {
  return 3;
}

以下代码会生成此诊断信息，因为函数 f 是生成器，并且正在隐式返回值：

dart
Stream<int> f() async* => 3;

常规修复

#

如果函数对函数体使用 => ，则将其转换为块函数体，并使用 yield 返回值：

dart
Stream<int> f() async* {
  yield 3;
}

如果该方法旨在作为生成器，则使用 yield 返回值：

dart
Iterable<int> f() sync* {
  yield 3;
}

如果该方法不旨在作为生成器，则从主体中删除修饰符（或者如果您要返回 future，则使用 async ）：

dart
int f() {
  return 3;
}

return_of_do_not_store

#

' {0}' 用 'doNotStore' 注释，除非 '{1}' 也被注释，否则不应返回。

说明

#

当用 doNotStore 注解注释的值从没有相同注解的方法、getter 或函数中返回时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为不应该存储调用 f 的结果，但函数 g 没有被注释以保留该语义：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => f();

常规修复

#

如果不应该存储的值是正确的返回值，则使用 doNotStore 注解标记该函数：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

@doNotStore
int g() => f();

否则，从函数中返回不同的值：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => 0;

return_of_invalid_type

#

类型为 '{0}' 的值无法从构造函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从方法 '{2}' 返回，因为它返回类型为 '{1}'。

说明

#

当方法或函数返回的值的类型无法赋值给声明的返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 的返回类型为 String ，但它返回的是 int ：

dart
String f() => 3;

常规修复

#

如果返回类型正确，则用正确类型的返回值替换正在返回的值，可能通过转换现有值：

dart
String f() => 3.toString();

redirect_to_non_const_constructor

#

常量重定向构造函数不能重定向到非常量构造函数。

说明

#

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

redirect_to_type_alias_expands_to_type_parameter

#

重定向构造函数不能重定向到扩展为类型参数的类型别名。

说明

#

当重定向工厂构造函数重定向到类型别名，并且类型别名扩展为类型别名的类型参数之一时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为对 B<A> 的重定向是到值为 T 的类型别名，即使该值应为 A ：

dart
class A implements C {}

typedef B<T> = T;

abstract class C {
  factory C() = B<A>;
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
class A implements C {}

abstract class C {
  factory C() = A;
}

referenced_before_declaration

#

局部变量 '{0}' 在声明之前不能被引用。

说明

#

当在声明变量之前引用变量时，分析器会生成此诊断信息。在 Dart 中，变量在其声明的块中的任何地方都是可见的，但只能在其声明之后才能被引用。

分析器还会生成上下文消息，指示声明的位置。

示例

#

以下代码会生成此诊断信息，因为 i 在声明之前被使用：

dart
void f() {
  print(i);
  int i = 5;
}

常规修复

#

如果您打算引用局部变量，请将声明移动到第一次引用之前：

dart
void f() {
  int i = 5;
  print(i);
}

如果您打算引用外部作用域中的名称，例如参数、实例字段或顶级变量，则重命名局部声明，使其不隐藏外部变量。

dart
void f(int i) {
  print(i);
  int x = 5;
  print(x);
}

refutable_pattern_in_irrefutable_context

#

可反驳的模式不能在不可反驳的上下文中使用。

说明

#

当在只允许 不可反驳的模式 的上下文中使用 可反驳的模式 时，分析器会生成此诊断信息。

不允许的可反驳模式是：

  • 逻辑或
  • 关系
  • 空检查
  • 常量

检查的上下文是：

  • 基于模式的变量声明
  • 基于模式的 for 循环
  • 左侧有模式的赋值

示例

#

以下代码会生成此诊断信息，因为空检查模式（它是一个可反驳的模式）位于基于模式的变量声明中，基于模式的变量声明不允许可反驳模式：

dart
void f(int? x) {
  var (_?) = x;
}

常规修复

#

重写代码，使其不在不可反驳的上下文中使用可反驳的模式。

relational_pattern_operand_type_not_assignable

#

常量表达式类型 '{0}' 无法赋值给 '{2}' 运算符的参数类型 '{1}'。

说明

#

当关系模式的操作数的类型无法赋值给将调用的运算符的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式（ 0 ）中的操作数是 int ，但 C 中定义的 > 运算符期望一个类型为 C 的对象：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > 0:
      print('positive');
  }
}

常规修复

#

如果 switch 使用正确的值，则更改 case 以将值与正确的对象类型进行比较：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > const C():
      print('positive');
  }
}

如果 switch 使用错误的值，则更改用于计算正在匹配的值的表达式：

dart
class C {
  const C();

  bool operator >(C other) => true;

  int get toInt => 0;
}

void f(C c) {
  switch (c.toInt) {
    case > 0:
      print('positive');
  }
}

relational_pattern_operator_return_type_not_assignable_to_bool

#

关系模式中使用的运算符的返回类型必须可赋值为 'bool'。

说明

#

当关系模式引用一个不产生类型为 bool 的值的运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式 > c2 中使用的运算符 > 返回类型为 int 的值而不是 bool ：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

常规修复

#

如果有其他应使用的运算符，则更改运算符：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case < c2) {}
}

如果运算符应返回 bool ，则更新运算符的声明：

dart
class C {
  const C();

  bool operator >(C c) => true;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

rest_element_in_map_pattern

#

映射模式不能包含 rest 模式。

说明

#

当映射模式包含 rest 模式时，分析器会生成此诊断信息。映射模式匹配键多于模式中显式给出的键的映射（只要给定的键匹配），因此 rest 模式是不必要的。

示例

#

以下代码会生成此诊断信息，因为映射模式包含 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _, ...}) {}
}

常规修复

#

删除 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _}) {}
}

rethrow_outside_catch

#

rethrow 必须位于 catch 子句中。

说明

#

当 rethrow 语句位于 catch 子句之外时，分析器会生成此诊断信息#### 说明

当在实例方法之外使用关键字 super 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 super 用于顶级函数中：

dart
void f() {
  super.f();
}

常规修复

#

重写代码以不使用 super 。

super_in_redirecting_constructor

#

重定向构造函数不能有 'super' 初始化器。

说明

#

当重定向到另一个构造函数的构造函数也尝试调用超类的构造函数时，分析器会生成此诊断信息。当调用重定向构造函数重定向到的构造函数时，将调用超类构造函数。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 同时重定向到 C.b 并调用超类的构造函数：

dart
class C {
  C.a() : this.b(), super();
  C.b();
}

常规修复

#

删除 super 构造函数的调用：

dart
class C {
  C.a() : this.b();
  C.b();
}

switch_case_completes_normally

#

'case' 不应正常完成。

说明

#

当 switch 语句中 case 标签后的语句可能贯穿到下一个 case 或 default 标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值为零 (0) 的 case 标签贯穿到 default 语句：

dart
void f(int a) {
  switch (a) {
    case 0:
      print(0);
    default:
      return;
  }
}

常规修复

#

更改控制流，以便 case 不会贯穿。这可以通过在当前语句列表的末尾添加以下内容之一来完成：

  • return 语句，
  • throw 表达式，
  • break 语句，
  • continue ，或
  • 返回类型为 Never 的函数或方法的调用。

switch_expression_not_assignable

#

switch 表达式的类型 '{0}' 无法赋值给 case 表达式的类型 '{1}'。

说明

#

当 switch 语句中的表达式的类型无法赋值给 case 子句中表达式的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 s 的类型（ String ）无法赋值给 0 的类型（ int ）：

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

常规修复

#

如果 case 表达式的类型正确，则更改 switch 语句中的表达式使其具有正确的类型：

dart
void f(String s) {
  switch (int.parse(s)) {
    case 0:
      break;
  }
}

如果 switch 表达式的类型正确，则更改 case 表达式使其具有正确的类型：

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

tearoff_of_generative_constructor_of_abstract_class

#

不能分离抽象类的生成式构造函数。

说明

#

当从抽象类中分离生成式构造函数时，分析器会生成此诊断信息。这是不允许的，因为实例化抽象类是无效的，这意味着分离的构造函数没有有效的用途。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.new 正在被分离，而类 C 是抽象类：

dart
abstract class C {
  C();
}

void f() {
  C.new;
}

常规修复

#

分离具体类的构造函数。

text_direction_code_point_in_comment

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

text_direction_code_point_in_literal

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

throw_of_invalid_type

#

抛出表达式的类型 '{0}' 必须可赋值为 'Object'。

说明

#

当 throw 表达式中的表达式的类型无法赋值给 Object 时，分析器会生成此诊断信息。抛出 null 是无效的，因此使用可能计算为 null 的表达式也是无效的。

示例

#

以下代码会生成此诊断信息，因为 s 可能为 null ：

dart
void f(String? s) {
  throw s;
}

常规修复

#

向表达式添加显式的空检查：

dart
void f(String? s) {
  throw s!;
}

top_level_cycle

#

无法推断 '{0}' 的类型，因为它通过循环依赖自身：{1}。

说明

#

当顶级变量没有类型注解，并且变量的初始化器直接或间接引用该变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息两次，因为两个常量都是根据另一个常量定义的，并且两者都没有显式类型，因此无法推断另一个的类型：

dart
var x = y;
var y = x;

常规修复

#

如果这两个变量不需要相互引用，则打破循环：

dart
var x = 0;
var y = x;

如果这两个变量需要相互引用，则至少为其中一个变量提供显式类型：

dart
int x = y;
var y = x;

但是，请注意，虽然此代码不会生成任何诊断信息，但除非在循环中的任何变量被引用之前，至少为一个变量赋值一个不依赖于其他变量的值，否则它会在运行时产生堆栈溢出。

type_alias_cannot_reference_itself

#

typedef 不能直接或通过另一个 typedef 递归地引用自身。

说明

#

当 typedef 直接或间接引用自身时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 通过 G 间接依赖于自身：

dart
typedef F = void Function(G);
typedef G = void Function(F);

常规修复

#

更改循环中的一个或多个 typedef，使它们都不引用自身：

dart
typedef F = void Function(G);
typedef G = void Function(int);

type_annotation_deferred_class

#

延迟加载类型 '{0}' 不能用于声明、强制转换或类型测试中。

说明

#

当类型注解位于变量声明中，或者在强制转换 (as) 或类型测试 (is) 中使用的类型是在使用延迟导入导入的库中声明的类型时，分析器会生成此诊断信息。这些类型需要在编译时可用，但不可用。

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

示例

#

以下代码会生成此诊断信息，因为参数 f 的类型是从延迟加载库导入的：

dart
import 'dart:io' deferred as io;

void f(io.File f) {}

常规修复

#

如果您需要引用导入的类型，则删除 deferred 关键字：

dart
import 'dart:io' as io;

void f(io.File f) {}

如果需要延迟导入，并且还有其他合适的类型，则使用该类型代替延迟加载库中的类型。

type_argument_not_matching_bounds

#

' {0}' 不符合类型参数 '{1}' 的边界 '{2}'。

说明

#

当类型参数不是相同类型或其对应类型参数的子类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 不是 num 的子类：

dart
class A<E extends num> {}

var a = A<String>();

常规修复

#

将类型参数更改为边界的子类：

dart
class A<E extends num> {}

var a = A<int>();

type_check_with_null

#

对非空的测试应使用 '!= null' 进行。

对 null 的测试应使用 '== null' 进行。

说明

#

当类型检查（使用 as 运算符）的类型为 Null 时，分析器会生成此诊断信息。只有一个值为 Null 类型，因此当显式测试 null 时，代码的可读性和性能都会更好。

示例

#

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为 null ：

dart
void f(String? s) {
  if (s is Null) {
    return;
  }
  print(s);
}

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为非 null ：

dart
void f(String? s) {
  if (s is! Null) {
    print(s);
  }
}

常规修复

#

将类型检查替换为与 null 的等效比较：

dart
void f(String? s) {
  if (s == null) {
    return;
  }
  print(s);
}

type_parameter_referenced_by_static

#

静态成员不能引用类的类型参数。

说明

#

当静态成员引用为类声明的类型参数时，分析器会生成此诊断信息。类型参数仅对类的实例有意义。

示例

#

以下代码会生成此诊断信息，因为静态方法 hasType 引用了类型参数 T ：

dart
class C<T> {
  static bool hasType(Object o) => o is T;
}

常规修复

#

如果成员可以是实例成员，则删除关键字 static ：

dart
class C<T> {
  bool hasType(Object o) => o is T;
}

如果成员必须是静态成员，则使成员成为泛型：

dart
class C<T> {
  static bool hasType<S>(Object o) => o is S;
}

但是，请注意， T 和 S 之间没有关系，因此第二个选项会更改与可能预期的语义。

type_parameter_supertype_of_its_bound

#

' {0}' 不能是其上限的超类型。

说明

#

当类型参数的边界（ extends 关键字后的类型）直接或间接为类型参数本身时，分析器会生成此诊断信息。声明类型参数必须与自身相同是没有意义的。

说明

#

当在实例方法之外使用关键字 super 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 super 用于顶级函数中：

dart
void f() {
  super.f();
}

常规修复

#

重写代码以不使用 super 。

super_in_redirecting_constructor

#

重定向构造函数不能有 'super' 初始化器。

说明

#

当重定向到另一个构造函数的构造函数也尝试调用超类的构造函数时，分析器会生成此诊断信息。当调用重定向构造函数重定向到的构造函数时，将调用超类构造函数。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 同时重定向到 C.b 并调用超类的构造函数：

dart
class C {
  C.a() : this.b(), super();
  C.b();
}

常规修复

#

删除 super 构造函数的调用：

dart
class C {
  C.a() : this.b();
  C.b();
}

switch_case_completes_normally

#

'case' 不应正常完成。

说明

#

当 switch 语句中 case 标签后的语句可能贯穿到下一个 case 或 default 标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值为零 (0) 的 case 标签贯穿到 default 语句：

dart
void f(int a) {
  switch (a) {
    case 0:
      print(0);
    default:
      return;
  }
}

常规修复

#

更改控制流，以便 case 不会贯穿。这可以通过在当前语句列表的末尾添加以下内容之一来完成：

  • 一个 return 语句，
  • 一个 throw 表达式，
  • 一个 break 语句，
  • 一个 continue ，或
  • 一个返回类型为 Never 的函数或方法的调用。

switch_expression_not_assignable

#

switch 表达式的类型 '{0}' 无法赋值给 case 表达式的类型 '{1}'。

说明

#

当 switch 语句中的表达式的类型无法赋值给 case 子句中表达式的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 s 的类型（ String ）无法赋值给 0 的类型（ int ）：

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

常规修复

#

如果 case 表达式的类型正确，则更改 switch 语句中的表达式使其具有正确的类型：

dart
void f(String s) {
  switch (int.parse(s)) {
    case 0:
      break;
  }
}

如果 switch 表达式的类型正确，则更改 case 表达式使其具有正确的类型：

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

tearoff_of_generative_constructor_of_abstract_class

#

不能分离抽象类的生成式构造函数。

说明

#

当从抽象类中分离生成式构造函数时，分析器会生成此诊断信息。这是不允许的，因为实例化抽象类是无效的，这意味着分离的构造函数没有有效的用途。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.new 正在被分离，而类 C 是抽象类：

dart
abstract class C {
  C();
}

void f() {
  C.new;
}

常规修复

#

分离具体类的构造函数。

text_direction_code_point_in_comment

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

text_direction_code_point_in_literal

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

throw_of_invalid_type

#

抛出表达式的类型 '{0}' 必须可赋值为 'Object'。

说明

#

当 throw 表达式中的表达式的类型无法赋值给 Object 时，分析器会生成此诊断信息。抛出 null 是无效的，因此使用可能计算为 null 的表达式也是无效的。

示例

#

以下代码会生成此诊断信息，因为 s 可能为 null ：

dart
void f(String? s) {
  throw s;
}

常规修复

#

向表达式添加显式的空检查：

dart
void f(String? s) {
  throw s!;
}

top_level_cycle

#

无法推断 '{0}' 的类型，因为它通过循环依赖自身：{1}。

说明

#

当顶级变量没有类型注解，并且变量的初始化器直接或间接引用该变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 x 和 y 是根据彼此定义的，并且两者都没有显式类型，因此无法推断另一个的类型：

dart
var x = y;
var y = x;

常规修复

#

如果这两个变量不需要相互引用，则打破循环：

dart
var x = 0;
var y = x;

如果这两个变量需要相互引用，则至少为其中一个变量提供显式类型：

dart
int x = y;
var y = x;

但是，请注意，虽然此代码不会生成任何诊断信息，但除非在循环中的任何变量被引用之前，至少为一个变量赋值一个不依赖于其他变量的值，否则它会在运行时产生堆栈溢出。

type_alias_cannot_reference_itself

#

typedef 不能直接或通过另一个 typedef 递归地引用自身。

说明

#

当 typedef 直接或间接引用自身时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 通过 G 间接依赖于自身：

dart
typedef F = void Function(G);
typedef G = void Function(F);

常规修复

#

更改循环中的一个或多个 typedef，使它们都不引用自身：

dart
typedef F = void Function(G);
typedef G = void Function(int);

type_annotation_deferred_class

#

延迟加载类型 '{0}' 不能用于声明、强制转换或类型测试中。

说明

#

当类型注解位于变量声明中，或者在强制转换 (as) 或类型测试 (is) 中使用的类型是在使用延迟导入导入的库中声明的类型时，分析器会生成此诊断信息。这些类型需要在编译时可用，但不可用。

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

示例

#

以下代码会生成此诊断信息，因为参数 f 的类型是从延迟加载库导入的：

dart
import 'dart:io' deferred as io;

void f(io.File f) {}

常规修复

#

如果您需要引用导入的类型，则删除 deferred 关键字：

dart
import 'dart:io' as io;

void f(io.File f) {}

如果需要延迟导入，并且还有其他合适的类型，则使用该类型代替延迟加载库中的类型。

type_argument_not_matching_bounds

#

' {0}' 不符合类型参数 '{1}' 的边界 '{2}'。

说明

#

当类型参数不是相同类型或其对应类型参数的子类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 不是 num 的子类：

dart
class A<E extends num> {}

var a = A<String>();

常规修复

#

将类型参数更改为边界的子类：

dart
class A<E extends num> {}

var a = A<int>();

type_check_with_null

#

对非空的测试应使用 '!= null' 进行。

对 null 的测试应使用 '== null' 进行。

说明

#

当类型检查（使用 as 运算符）的类型为 Null 时，分析器会生成此诊断信息。只有一个值为 Null 类型，因此当显式测试 null 时，代码的可读性和性能都会更好。

示例

#

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为 null ：

dart
void f(String? s) {
  if (s is Null) {
    return;
  }
  print(s);
}

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为非 null ：

dart
void f(String? s) {
  if (s is! Null) {
    print(s);
  }
}

常规修复

#

将类型检查替换为与 null 的等效比较：

dart
void f(String? s) {
  if (s == null) {
    return;
  }
  print(s);
}

type_parameter_referenced_by_static

#

静态成员不能引用类的类型参数。

说明

#

当静态成员引用为类声明的类型参数时，分析器会生成此诊断信息。类型参数仅对类的实例有意义。

示例

#

以下代码会生成此诊断信息，因为静态方法 hasType 引用了类型参数 T ：

dart
class C<T> {
  static bool hasType(Object o) => o is T;
}

常规修复

#

如果成员可以是实例成员，则删除关键字 static ：

dart
class C<T> {
  bool hasType(Object o) => o is T;
}

如果成员必须是静态成员，则使成员成为泛型：

dart
class C<T> {
  static bool hasType<S>(Object o) => o is S;
}

但是，请注意， T 和 S 之间没有关系，因此第二个选项会更改与可能预期的语义。

type_parameter_supertype_of_its_bound

#

' {0}' 不能是其上限的超类型。

说明

#

当类型参数的边界（ extends 关键字后的类型）直接或间接为类型参数本身时，分析器会生成此诊断信息。声明类型参数必须与自身相同是没有意义的。

示例

#

以下代码会生成此诊断信息，因为 T 的边界是 T ：

dart
class C<T extends T> {}

以下代码会生成此诊断信息，因为 T1 的边界是 T2 ，而 T2 的边界是 T1 ，有效地使 T1 的边界为 T1 ：

dart
class C<T1 extends T2, T2 extends T1> {}

常规修复

#

如果类型参数需要是某种类型的子类，则用所需的类型替换边界：

dart
class C<T extends num> {}

如果类型参数可以是任何类型，则删除 extends 子句：

dart
class C<T> {}

type_test_with_non_type

#

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

说明

#

当 is 或 is! 测试的右侧不是类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为右侧是参数，而不是类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is b) {
    return;
  }
}

常规修复

#

如果您打算使用类型测试，则将右侧替换为类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is B) {
    return;
  }
}

如果您打算使用其他类型的测试，则更改测试：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a == b) {
    return;
  }
}

type_test_with_undefined_name

#

名称 '{0}' 未定义，因此不能在 'is' 表达式中使用。

说明

#

当类型测试表达式中的 is 后的名称未定义时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 Srting 未定义：

dart
void f(Object o) {
  if (o is Srting) {
    // ...
  }
}

常规修复

#

将名称替换为类型的名称：

dart
void f(Object o) {
  if (o is String) {
    // ...
  }
}

unchecked_use_of_nullable_value

#

可空表达式不能用作条件。

可空表达式不能用作 for-in 循环中的迭代器。

可空表达式不能用于展开中。

可空表达式不能用于 yield-each 语句中。

由于函数可能为 'null'，因此不能无条件调用该函数。

由于接收者可能为 'null'，因此不能无条件调用方法 '{0}'。

由于接收者可能为 'null'，因此不能无条件调用运算符 '{0}'。

由于接收者可能为 'null'，因此不能无条件访问属性 '{0}'。

说明

#

当在不首先验证值是否为 null 的情况下取消引用类型为 潜在的非空类型 的表达式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为在引用 s 时， s 可能为 null ：

dart
void f(String? s) {
  if (s.length > 3) {
    // ...
  }
}

常规修复

#

如果该值确实可以为 null ，则添加一个测试以确保只有在该值不为 null 时才访问成员：

dart
void f(String? s) {
  if (s != null && s.length > 3) {
    // ...
  }
}

如果该表达式是变量，并且该值绝不应为 null ，则将变量的类型更改为非空：

dart
void f(String s) {
  if (s.length > 3) {
    // ...
  }
}

如果您认为表达式的值绝不应为 null ，但您无法更改变量的类型，并且您愿意承担如果出错则在运行时抛出异常的风险，则可以断言该值不为 null：

dart
void f(String? s) {
  if (s!.length > 3) {
    // ...
  }
}

undefined_annotation

#

用作注解的未定义名称 '{0}'。

说明

#

当使用未定义的名称作为注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 undefined 未定义：

dart
@undefined
void f() {}

常规修复

#

如果名称正确，但尚未声明，则将其声明为常量值：

dart
const undefined = 'undefined';

@undefined
void f() {}

如果名称错误，则将名称替换为有效常量的名称：

dart
@deprecated
void f() {}

否则，删除注解。

undefined_class

#

未定义的类 '{0}'。

说明

#

当遇到看起来像是类的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 Piont 未定义：

dart
class Point {}

void f(Piont p) {}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的类的名称。可以通过修复类的拼写来更正上面的示例：

dart
class Point {}

void f(Point p) {}

如果已定义该类但不可见，则可能需要添加导入。

undefined_constructor_in_initializer

#

类 '{0}' 没有名为 '{1}' 的构造函数。

类 '{0}' 没有未命名的构造函数。

说明

#

当在构造函数的初始化器列表中调用超类构造函数，但超类没有定义正在调用的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 没有未命名的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super();
}

以下代码会生成此诊断信息，因为 A 没有名为 m 的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.m();
}

常规修复

#

如果超类定义了应调用的构造函数，则更改正在调用的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.n();
}

如果超类没有定义合适的构造函数，则定义正在调用的构造函数：

dart
class A {
  A.m();
  A.n();
}
class B extends A {
  B() : super.m();
}

undefined_enum_constant

#

'{1}' 中没有名为 '{0}' 的常量。

说明

#

当遇到看起来像是枚举值的名称的标识符，并且该名称在其被引用的作用域中未定义或不可见时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 E 没有定义名为 c 的常量：

dart
enum E {a, b}

var e = E.c;

常规修复

#

如果应定义该常量，则将其添加到枚举的声明中：

dart
enum E {a, b, c}

var e = E.c;

如果不应定义该常量，则将名称更改为现有常量的名称：

dart
enum E {a, b}

var e = E.b;

undefined_enum_constructor

#

枚举没有名为 '{0}' 的构造函数。

枚举没有未命名的构造函数。

说明

#

当调用用于初始化枚举值的构造函数不存在时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为枚举值 c 由未命名的构造函数初始化，但在 E 中没有定义未命名的构造函数：

dart
enum E {
  c() ;

  const E.x();
}

以下代码会生成此诊断信息，因为枚举值 c 由名为 x 的构造函数初始化，但在 E 中没有定义名为 x 的构造函数：

dart
enum E {
  c. x() ;

  const E.y();
}

常规修复

#

如果枚举值由未命名的构造函数初始化，并且应使用命名构造函数之一，则添加构造函数的名称：

dart
enum E {
  c.x();

  const E.x();
}

如果枚举值由未命名的构造函数初始化，并且命名构造函数都不合适，则定义未命名的构造函数：

dart
enum E {
  c();

  const E();
}

如果枚举值由命名的构造函数初始化，并且应使用现有的构造函数之一，则更改正在调用的构造函数的名称（或者如果应使用未命名的构造函数，则将其删除）：

dart
enum E {
  c.y();

  const E();
  const E.y();
}

如果枚举值由命名的构造函数初始化，并且现有构造函数都不应使用，则定义一个具有所用名称的构造函数：

dart
enum E {
  c.x();

  const E.x();
}

undefined_extension_getter

#

扩展 '{1}' 没有定义 getter '{0}'。

说明

#

当使用扩展重写调用 getter，但指定的扩展没有定义该 getter 时，分析器会生成此诊断信息。当引用静态 getter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 getter：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 getter：

dart
extension E on String {}

var x = E.a;

常规修复

#

如果 getter 的名称不正确，则将其更改为现有 getter 的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').a;
}

如果 getter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  F('c').b;
}

如果 getter 和扩展的名称都正确，但未定义 getter，则定义 getter：

dart
extension E on String {
  String get a => 'a';
  String get b => 'z';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

undefined_extension_method

#

扩展 '{1}' 没有定义方法 '{0}'。

说明

#

当使用扩展重写调用方法，但指定的扩展没有定义该方法时，分析器会生成此诊断信息。当引用静态方法但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例方法：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c'). b() ;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态方法：

dart
extension E on String {}

var x = E. a() ;

常规修复

#

如果方法的名称不正确，则将其更改为现有方法的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').a();
}

如果方法的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  F('c').b();
}

如果方法和扩展的名称都正确，但未定义该方法，则定义该方法：

dart
extension E on String {
  String a() => 'a';
  String b() => 'z';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').b();
}

说明

#

当扩展没有实现该运算符时，在特定扩展上调用运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有定义运算符 * ：

dart
var x = E('') * 4;

extension E on String {}

常规修复

#

如果扩展预计要实现该运算符，则向扩展中添加运算符的实现：

dart
var x = E('') * 4;

extension E on String {
  int operator *(int multiplier) => length * multiplier;
}

如果运算符由不同的扩展定义，则将扩展的名称更改为定义运算符的扩展的名称。

如果运算符在扩展重写的参数上定义，则删除扩展重写：

dart
var x = '' * 4;

extension E on String {}

undefined_extension_setter

#

扩展 '{1}' 没有定义 setter '{0}'。

说明

#

当使用扩展重写调用 setter，但指定的扩展没有定义该 setter 时，分析器会生成此诊断信息。当引用静态 setter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 setter：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 setter：

dart
extension E on String {}

void f() {
  E.a = 3;
}

常规修复

#

如果 setter 的名称不正确，则将其更改为现有 setter 的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').a = 'd';
}

如果 setter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  F('c').b = 'd';
}

如果 setter 和扩展的名称都正确，但未定义 setter，则定义 setter：

dart
extension E on String {
  set a(String v) {}
  set b(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

undefined_function

#

函数 '{0}' 未定义。

说明

#

当遇到看起来像是函数的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 emty 未定义：

dart
List<int> empty() => [];

void main() {
  print(emty());
}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的函数的名称。可以通过修复函数的拼写来更正上面的示例：

dart
List<int> empty() => [];

void main() {
  print(empty());
}

如果已定义该函数但不可见，则可能需要添加导入或重新排列代码以使该函数可见。

undefined_getter

#

getter '{0}' 未在 '{1}' 函数类型中定义。

getter '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是 getter 的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 没有名为 len 的成员：

dart
int f(String s) => s.len;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的 getter 的名称。可以通过修复 getter 的拼写来更正上面的示例：

dart
int f(String s) => s.length;

undefined_hidden_name

#

库 '{0}' 没有导出具有隐藏名称 '{1}' 的成员。

说明

#

当隐藏组合器包含未由导入的库定义的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:math 没有定义名称 String ：

dart
import 'dart:math' hide String, max;

var x = min(0, 1);

常规修复

#

如果应隐藏不同的名称，则更正名称。否则，从列表中删除名称：

dart
import 'dart:math' hide max;

var x = min(0, 1);

undefined_identifier

#

未定义的名称 '{0}'。

说明

#

当遇到未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 rihgt 未定义：

dart
int min(int left, int right) => left <= rihgt ? left : right;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的标识符。可以通过修复变量的拼写来更正上面的示例：

dart
int min(int left, int right) => left <= right ? left : right;

如果已定义标识符但不可见，则可能需要添加导入或重新排列代码以使标识符可见。

undefined_identifier_await

#

在未用 'async' 标记的函数体中未定义名称 'await'。

说明

#

当在方法或函数体中使用名称 await 但未声明，并且主体未用 async 关键字标记时，分析器会生成此诊断信息。名称 await 仅在异步函数中引入 await 表达式。

示例

#

以下代码会生成此诊断信息，因为名称 await 用于 f 的主体中，即使 f 的主体未用 async 关键字标记：

dart
void f(p) { await p; }

常规修复

#

向函数体添加关键字 async ：

dart
void f(p) async { await p; }

undefined_method

#

方法 '{0}' 未在 '{1}' 函数类型中定义。

方法 '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是方法的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标识符 removeMiddle 未定义：

dart
int f(List<int> l) => l. removeMiddle() ;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的方法的名称。可以通过修复方法的拼写来更正上面的示例：

dart
int f(List<int> l) => l.removeLast();

undefined_named_parameter

#

命名参数 '{0}' 未定义。

说明

#

当方法或函数调用具有命名参数，但正在调用的方法或函数没有定义具有相同名称的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 没有声明名为 a 的命名参数：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

常规修复

#

如果参数名称键入错误，则将其替换为正确的名称。可以通过将 a 更改为 b 来修复上面的示例：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(b: 1);
}

如果子类添加了一个具有该名称的参数，则将接收者强制转换为子类：

dart
class C {
  m({int? b}) {}
}

class D extends C {
  m({int? a, int? b}) {}
}

void f(C c) {
  (c as D).m(a: 1);
}

如果应将参数添加到函数，则添加它：

dart
class C {
  m({int? a, int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

undefined_operator

#

运算符 '{0}' 未在类型 '{1}' 中定义。

说明

#

当对未定义运算符的对象调用用户可定义的运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 C 没有定义运算符 + ：

dart
class C {}

C f(C c) => c + 2;

常规修复

#

如果应为该类定义运算符，则定义它：

dart
class C {
  C operator +(int i) => this;
}

C f(C c) => c + 2;

undefined_prefixed_name

#

名称 '{0}' 通过前缀 '{1}' 引用，但未在使用该前缀导入的任何库中定义。

说明

#

当找到前缀标识符时，前缀有效，但标识符未在使用该前缀导入的任何库中声明，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:core 没有定义任何名为 a 的内容：

dart
import 'dart:core' as p;

void f() {
  p.a;
}

常规修复

#

如果尚未导入声明名称的库，则添加该库的导入。

如果名称错误，则将其更改为导入库中声明的名称之一。

undefined_referenced_parameter

#

参数 '{0}' 未由 '{1}' 定义。

说明

#

当表单为 UseResult.unless(parameterDefined: parameterName) 的注解指定了未由被注解的函数定义的参数名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 没有名为 b 的参数：

dart
import 'package:meta/meta.dart';

@UseResult.unless(parameterDefined: 'b')
int f([int? a]) => a ?? 0;

常规修复

#

将名为 parameterDefined 的参数更改为与函数的参数之一的名称匹配：

dart
import 'package:meta/meta.dart';

@UseResult.unless(parameterDefined: 'a')
int f([int? a]) => a ?? 0;

undefined_setter

#

setter '{0}' 未在 '{1}' 函数类型中定义。

setter '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是 setter 的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为没有名为 z 的 setter：

dart
class C {
  int x = 0;
  void m(int y) {
    this.z = y;
  }
}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的 setter 的名称。可以通过修复 setter 的拼写来更正上面的示例：

dart
class C {
  int x = 0;
  void m(int y) {
    this.x = y;
  }
}

undefined_shown_name

#

库 '{0}' 没有导出具有显示名称 '{1}' 的成员。

说明

#

当显示组合器包含未由导入的库定义的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:math 没有定义名称 String ：

dart
import 'dart:math' show min, String;

var x = min(0, 1);

常规修复

#

如果应显示不同的名称，则更正名称。否则，从列表中删除名称：

dart
import 'dart:math' show min;

var x = min(0, 1);

undefined_super_member

#

(以前称为 undefined_super_method)

说明

#

当在超类中调用不存在的成员时，分析器会生成此诊断信息。

说明

#

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

redirect_to_type_alias_expands_to_type_parameter

#

重定向构造函数不能重定向到扩展为类型参数的类型别名。

说明

#

当重定向工厂构造函数重定向到类型别名，并且类型别名扩展为类型别名的类型参数之一时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为对 B<A> 的重定向是到值为 T 的类型别名，即使该值应为 A ：

dart
class A implements C {}

typedef B<T> = T;

abstract class C {
  factory C() = B<A>;
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
class A implements C {}

abstract class C {
  factory C() = A;
}

referenced_before_declaration

#

局部变量 '{0}' 在声明之前不能被引用。

说明

#

当在声明变量之前引用变量时，分析器会生成此诊断信息。在 Dart 中，变量在其声明的块中的任何地方都是可见的，但只能在其声明之后才能被引用。

分析器还会生成上下文消息，指示声明的位置。

示例

#

以下代码会生成此诊断信息，因为 i 在声明之前被使用：

dart
void f() {
  print(i);
  int i = 5;
}

常规修复

#

如果您打算引用局部变量，请将声明移动到第一次引用之前：

dart
void f() {
  int i = 5;
  print(i);
}

如果您打算引用外部作用域中的名称，例如参数、实例字段或顶级变量，则重命名局部声明，使其不隐藏外部变量。

dart
void f(int i) {
  print(i);
  int x = 5;
  print(x);
}

refutable_pattern_in_irrefutable_context

#

可反驳的模式不能在不可反驳的上下文中使用。

说明

#

当在只允许 不可反驳的模式 的上下文中使用 可反驳的模式 时，分析器会生成此诊断信息。

不允许的可反驳模式是：

  • 逻辑或
  • 关系
  • 空检查
  • 常量

检查的上下文是：

  • 基于模式的变量声明
  • 基于模式的 for 循环
  • 左侧有模式的赋值

示例

#

以下代码会生成此诊断信息，因为空检查模式（它是一个可反驳的模式）位于基于模式的变量声明中，基于模式的变量声明不允许可反驳模式：

dart
void f(int? x) {
  var (_?) = x;
}

常规修复

#

重写代码，使其不在不可反驳的上下文中使用可反驳的模式。

relational_pattern_operand_type_not_assignable

#

常量表达式类型 '{0}' 无法赋值给 '{2}' 运算符的参数类型 '{1}'。

说明

#

当关系模式的操作数的类型无法赋值给将调用的运算符的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式（ 0 ）中的操作数是 int ，但 C 中定义的 > 运算符期望一个类型为 C 的对象：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > 0:
      print('positive');
  }
}

常规修复

#

如果 switch 使用正确的值，则更改 case 以将值与正确的对象类型进行比较：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > const C():
      print('positive');
  }
}

如果 switch 使用错误的值，则更改用于计算正在匹配的值的表达式：

dart
class C {
  const C();

  bool operator >(C other) => true;

  int get toInt => 0;
}

void f(C c) {
  switch (c.toInt) {
    case > 0:
      print('positive');
  }
}

relational_pattern_operator_return_type_not_assignable_to_bool

#

关系模式中使用的运算符的返回类型必须可赋值为 'bool'。

说明

#

当关系模式引用一个不产生类型为 bool 的值的运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式 > c2 中使用的运算符 > 返回类型为 int 的值而不是 bool ：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

常规修复

#

如果有其他应使用的运算符，则更改运算符：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case < c2) {}
}

如果运算符应返回 bool ，则更新运算符的声明：

dart
class C {
  const C();

  bool operator >(C c) => true;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

rest_element_in_map_pattern

#

映射模式不能包含 rest 模式。

说明

#

当映射模式包含 rest 模式时，分析器会生成此诊断信息。映射模式匹配键多于模式中显式给出的键的映射（只要给定的键匹配），因此 rest 模式是不必要的。

示例

#

以下代码会生成此诊断信息，因为映射模式包含 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _, ...}) {}
}

常规修复

#

删除 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _}) {}
}

rethrow_outside_catch

#

rethrow 必须位于 catch 子句中。

说明

#

当 rethrow 语句位于 catch 子句之外时，分析器会生成此诊断信息。 rethrow 语句用于再次抛出捕获的异常，但在 catch 子句之外没有捕获的异常。

示例

#

以下代码会生成此诊断信息，因为 rethrow 语句位于 catch 子句之外：

dart
void f() {
  rethrow;
}

常规修复

#

如果您尝试重新抛出异常，则将 rethrow 语句包装在 catch 子句中：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    rethrow;
  }
}

如果您尝试抛出一个新的异常，则将 rethrow 语句替换为 throw 表达式：

dart
void f() {
  throw UnsupportedError('Not yet implemented');
}

return_in_generative_constructor

#

构造函数不能返回值。

说明

#

当生成式构造函数包含一个指定要返回的值的 return 语句时，分析器会生成此诊断信息。生成式构造函数始终返回已创建的对象，因此不能返回不同的对象。

示例

#

以下代码会生成此诊断信息，因为 return 语句有一个表达式：

dart
class C {
  C() {
    return this;
  }
}

常规修复

#

如果构造函数应创建一个新的实例，则删除 return 语句或表达式：

dart
class C {
  C();
}

如果构造函数不应创建新的实例，则将其转换为工厂构造函数：

dart
class C {
  factory C() {
    return _instance;
  }

  static C _instance = C._();

  C._();
}

return_in_generator

#

不能从使用 'async*' 或 'sync*' 修饰符的生成器函数返回值。

说明

#

当生成器函数（其主体用 async* 或 sync* 标记）使用 return 语句返回值或由于使用 => 而隐式返回值时，分析器会生成此诊断信息。在任何这些情况下，它们都应使用 yield 代替 return 。

示例

#

以下代码会生成此诊断信息，因为方法 f 是生成器，并且正在使用 return 返回值：

dart
Iterable<int> f() sync* {
  return 3;
}

以下代码会生成此诊断信息，因为函数 f 是生成器，并且正在隐式返回值：

dart
Stream<int> f() async* => 3;

常规修复

#

如果函数对函数体使用 => ，则将其转换为块函数体，并使用 yield 返回值：

dart
Stream<int> f() async* {
  yield 3;
}

如果该方法旨在作为生成器，则使用 yield 返回值：

dart
Iterable<int> f() sync* {
  yield 3;
}

如果该方法不旨在作为生成器，则从主体中删除修饰符（或者如果您要返回 future，则使用 async ）：

dart
int f() {
  return 3;
}

return_of_do_not_store

#

' {0}' 用 'doNotStore' 注释，除非 '{1}' 也被注释，否则不应返回。

说明

#

当用 doNotStore 注解注释的值从没有相同注解的方法、getter 或函数中返回时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为不应该存储调用 f 的结果，但函数 g 没有被注释以保留该语义：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => f();

常规修复

#

如果不应该存储的值是正确的返回值，则使用 doNotStore 注解标记该函数：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

@doNotStore
int g() => f();

否则，从函数中返回不同的值：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => 0;

return_of_invalid_type

#

类型为 '{0}' 的值无法从构造函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从方法 '{2}' 返回，因为它返回类型为 '{1}'。

说明

#

当方法或函数返回的值的类型无法赋值给声明的返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 的返回类型为 String ，但它返回的是 int ：

dart
String f() => 3;

常规修复

#

如果返回类型正确，则用正确类型的返回值替换正在返回的值，可能通过转换现有值：

dart
String f() => 3.toString();

redirect_to_non_const_constructor

#

常量重定向构造函数不能重定向到非常量构造函数。

说明

#

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是 const 构造函数：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

如果生成式构造函数是未命名的构造函数，并且没有参数传递给它，则可以删除超类调用。

non_generative_implicit_constructor

#

超类 '{0}' 的未命名构造函数（由 '{1}' 的默认构造函数调用）必须是生成式构造函数，但找到了工厂构造函数。

说明

#

当类具有隐式生成式构造函数，而超类具有显式未命名的工厂构造函数时，分析器会生成此诊断信息。子类中的隐式构造函数隐式调用超类中的未命名构造函数，但生成式构造函数只能调用另一个生成式构造函数，而不能调用工厂构造函数。

示例

#

以下代码会生成此诊断信息，因为 B 中的隐式构造函数调用 A 中的未命名构造函数，但 A 中的构造函数是工厂构造函数，而需要生成式构造函数：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B extends A {}

常规修复

#

如果超类中的未命名构造函数可以是生成式构造函数，则将其更改为生成式构造函数：

dart
class A {
  A();
  A.named();
}

class B extends A { }

如果未命名构造函数不能是生成式构造函数，并且超类中还有其他生成式构造函数，则显式调用其中一个：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B extends A {
  B() : super.named();
}

如果没有可以使用的生成式构造函数，并且不能添加任何生成式构造函数，则实现超类而不是扩展它：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B implements A {}

non_native_function_type_argument_to_pointer

#

无法调用 'asFunction'，因为指针的函数签名 '{0}' 不是有效的 C 函数签名。

说明

#

当在指向本机函数的指针上调用 asFunction 方法，但本机函数的签名不是有效的 C 函数签名时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为与指针 p 关联的函数签名（ FNative ）不是有效的 C 函数签名：

dart
import 'dart:ffi';

typedef FNative = int Function(int);
typedef F = int Function(int);

class C {
  void f(Pointer<NativeFunction<FNative>> p) {
    p.asFunction<F>();
  }
}

常规修复

#

使 NativeFunction 签名成为有效的 C 签名：

dart
import 'dart:ffi';

typedef FNative = Int8 Function(Int8);
typedef F = int Function(int);

class C {
  void f(Pointer<NativeFunction<FNative>> p) {
    p.asFunction<F>();
  }
}

non_positive_array_dimension

#

数组维度必须是正数。

说明

#

当 Array 注解中给定的维度小于或等于零 (0) 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为提供了 -1 的数组维度：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array(-8)
  external Array<Uint8> a0;
}

常规修复

#

将维度更改为正整数：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

如果这是一个可变长度的内联数组，则将注解更改为 Array.variable() ：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array.variable()
  external Array<Uint8> a0;
}

non_sized_type_argument

#

类型 '{1}' 不是 '{0}' 的有效类型参数。类型参数必须是本机整数、'Float'、'Double'、'Pointer' 或 'Struct'、'Union' 或 'AbiSpecificInteger' 的子类型。

说明

#

当 Array 类的类型参数不是有效类型之一时，分析器会生成此诊断信息：本机整数、 Float 、 Double 、 Pointer 或 Struct 、 Union 或 AbiSpecificInteger 的子类型。

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

示例

#

以下代码会生成此诊断信息，因为 Array 的类型参数是 Void ，而 Void 不是有效类型之一：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Void> a0;
}

常规修复

#

将类型参数更改为有效类型之一：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

non_sync_factory

#

工厂体不能使用 'async'、'async*' 或 'sync*'。

说明

#

当工厂构造函数的体用 async 、 async* 或 sync* 标记时，分析器会生成此诊断信息。所有构造函数（包括工厂构造函数）都需要返回声明它们的类的实例，而不是 Future 、 Stream 或 Iterator 。

示例

#

以下代码会生成此诊断信息，因为工厂构造函数的体用 async 标记：

dart
class C {
  factory C() async {
    return C._();
  }
  C._();
}

常规修复

#

如果必须将成员声明为工厂构造函数，则删除主体之前的关键字：

dart
class C {
  factory C() {
    return C._();
  }
  C._();
}

如果成员必须返回除封闭类的实例以外的其他内容，则将成员设为静态方法：

dart
class C {
  static Future<C> m() async {
    return C._();
  }
  C._();
}

non_type_as_type_argument

#

名称 '{0}' 不是类型，因此不能用作类型参数。

说明

#

当不是类型的标识符用作类型参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 是变量，而不是类型：

dart
var x = 0;
List<x> xList = [];

常规修复

#

将类型参数更改为类型：

dart
var x = 0;
List<int> xList = [];

non_type_in_catch_clause

#

名称 '{0}' 不是类型，不能用于 on-catch 子句中。

说明

#

当 catch 子句中的 on 后的标识符被定义为非类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是函数，而不是类型：

dart
void f() {
  try {
    // ...
  } on f {
    // ...
  }
}

常规修复

#

将名称更改为应捕获的对象类型：

dart
void f() {
  try {
    // ...
  } on FormatException {
    // ...
  }
}

non_void_return_for_operator

#

运算符 []= 的返回类型必须是 'void'。

说明

#

当 []= 运算符的声明的返回类型不是 void 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 []= 运算符的声明的返回类型为 int ：

dart
class C {
  int operator []=(int index, int value) => 0;
}

常规修复

#

将返回类型更改为 void ：

dart
class C {
  void operator []=(int index, int value) => 0;
}

non_void_return_for_setter

#

setter 的返回类型必须是 'void' 或不存在。

说明

#

当 setter 的定义的返回类型不是 void 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 setter p 的返回类型为 int ：

dart
class C {
  int set p(int i) => 0;
}

常规修复

#

将返回类型更改为 void 或省略返回类型：

dart
class C {
  set p(int i) => 0;
}

not_assigned_potentially_non_nullable_local_variable

#

非空局部变量 '{0}' 必须在使用之前赋值。

说明

#

当引用局部变量并且具有以下所有特征时，分析器会生成此诊断信息：

  • 具有 潜在的非空类型 。
  • 没有初始化器。
  • 未标记为 late 。
  • 分析器无法根据 明确赋值 的规范证明在引用之前将为局部变量赋值。

示例

#

以下代码会生成此诊断信息，因为 x 不能具有 null 值，但在为其赋值之前就被引用了：

dart
String f() {
  int x;
  return x.toString();
}

以下代码会生成此诊断信息，因为对 x 的赋值可能不会执行，因此它可能具有 null 值：

dart
int g(bool b) {
  int x;
  if (b) {
    x = 1;
  }
  return x * 2;
}

以下代码会生成此诊断信息，因为分析器无法根据明确赋值分析证明 x 不会在未为其赋值的情况下被引用：

dart
int h(bool b) {
  int x;
  if (b) {
    x = 1;
  }
  if (b) {
    return x * 2;
  }
  return 0;
}

常规修复

#

如果 null 是有效值，则使变量可为空：

dart
String f() {
  int? x;
  return x!.toString();
}

如果 null 不是有效值，并且有合理的默认值，则添加初始化器：

dart
int g(bool b) {
  int x = 2;
  if (b) {
    x = 1;
  }
  return x * 2;
}

否则，确保在访问该值之前，在每条可能的代码路径上都为其赋值：

dart
int g(bool b) {
  int x;
  if (b) {
    x = 1;
  } else {
    x = 2;
  }
  return x * 2;
}

您也可以将变量标记为 late ，这将删除诊断信息，但如果在访问变量之前未为其赋值，则会导致在运行时抛出异常。只有在您确定变量将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
int h(bool b) {
  late int x;
  if (b) {
    x = 1;
  }
  if (b) {
    return x * 2;
  }
  return 0;
}

not_a_type

#

{0} 不是类型。

说明

#

当名称用作类型但被声明为非类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是函数：

dart
f() {}
g(f v) {}

常规修复

#

将名称替换为类型的名称。

not_binary_operator

#

' {0}' 不是二元运算符。

说明

#

当只能用作一元运算符的运算符用作二元运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为运算符 ~ 只能用作一元运算符：

dart
var a = 5 ~ 3;

常规修复

#

将运算符替换为正确的二元运算符：

dart
var a = 5 - 3;

not_enough_positional_arguments

#

' {0}' 预期有 1 个位置参数，但找到 0 个。

预期有 1 个位置参数，但找到 0 个。

' {2}' 预期有 {0} 个位置参数，但找到 {1} 个。

预期有 {0} 个位置参数，但找到 {1} 个。

说明

#

当方法或函数调用的位置参数少于必需位置参数的数量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 声明了两个必需参数，但只提供了一个参数：

dart
void f(int a, int b) {}
void g() {
  f(0);
}

常规修复

#

添加与其余参数对应的参数：

dart
void f(int a, int b) {}
void g() {
  f(0, 1);
}

not_initialized_non_nullable_instance_field

#

非空实例字段 '{0}' 必须初始化。

说明

#

当声明字段并具有以下所有特征时，分析器会生成此诊断信息：

示例

#

以下代码会生成此诊断信息，因为 x 在不允许为 null 时隐式初始化为 null ：

dart
class C {
  int x;
}

类似地，以下代码会生成此诊断信息，因为 x 在不允许为 null 时被其中一个构造函数隐式初始化为 null ，即使它由其他构造函数初始化：

dart
class C {
  int x;

  C(this.x);

  C.n();
}

常规修复

#

如果所有实例的字段都有合理的默认值，则添加初始化表达式：

dart
class C {
  int x = 0;
}

如果在创建实例时应提供字段的值，则添加一个设置字段值的构造函数或更新现有构造函数：

dart
class C {
  int x;

  C(this.x);
}

您还可以将字段标记为 late ，这将删除诊断信息，但如果在访问字段之前未为其赋值，则会导致在运行时抛出异常。只有在您确定字段在引用之前将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
class C {
  late int x;
}

not_initialized_non_nullable_variable

#

非空变量 '{0}' 必须初始化。

说明

#

当静态字段或顶级变量具有非空类型并且没有初始化器时，分析器会生成此诊断信息。通常，没有初始化器的字段和变量被初始化为 null ，但字段或变量的类型不允许将其设置为 null ，因此必须提供显式初始化器。

示例

#

以下代码会生成此诊断信息，因为字段 f 不能初始化为 null ：

dart
class C {
  static int f;
}

类似地，以下代码会生成此诊断信息，因为顶级变量 v 不能初始化为 null ：

dart
int v;

常规修复

#

如果字段或变量不能初始化为 null ，则添加一个将其设置为非空值的初始化器：

dart
class C {
  static int f = 0;
}

如果字段或变量应初始化为 null ，则将类型更改为可为空：

dart
int? v;

如果字段或变量不能在声明中初始化，但在引用之前将始终初始化，则将其标记为 late ：

dart
class C {
  static late int f;
}

not_iterable_spread

#

列表或集合字面量中的展开元素必须实现 'Iterable'。

说明

#

当出现在列表字面量或集合字面量中的展开元素的表达式的静态类型没有实现类型 Iterable 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m};

常规修复

#

最常见的修复方法是用产生可迭代对象的表达式替换该表达式：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m.keys};

not_map_spread

#

映射字面量中的展开元素必须实现 'Map'。

说明

#

当出现在映射字面量中的展开元素的表达式的静态类型没有实现类型 Map 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 l 不是 Map ：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l};

常规修复

#

最常见的修复方法是用产生映射的表达式替换该表达式：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l.asMap()};

no_annotation_constructor_arguments

#

注解创建必须有参数。

说明

#

当注解由单个标识符组成，但该标识符是类的名称而不是变量的名称时，分析器会生成此诊断信息。要创建类的实例，标识符后必须跟一个参数列表。

示例

#

以下代码会生成此诊断信息，因为 C 是一个类，并且如果没有从类中调用 const 构造函数，则不能将类用作注解：

dart
class C {
  const C();
}

@C
var x;

常规修复

#

添加缺少的参数列表：

dart
class C {
  const C();
}

@C()
var x;

no_combined_super_signature

#

无法从被覆盖的方法推断 '{0}' 中缺少的类型：{1}。

说明

#

当存在需要推断一个或多个类型的函数声明，并且由于没有被覆盖的方法的函数类型是所有其他被覆盖方法的超类型（如 覆盖推断 所指定）时，无法推断这些类型，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 C 中声明的方法 m 缺少返回类型和参数 a 的类型，并且无法为其推断任何缺少的类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  m(a) ;
}

在此示例中，无法执行覆盖推断，因为被覆盖的方法在以下方面不兼容：

  • 参数类型（ String 和 int ）都不是对方的超类型。
  • 返回类型都不是对方的子类型。

常规修复

#

如果可能，向子类中与所有被覆盖方法的类型一致的方法添加类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  C m(Object a);
}

no_generative_constructors_in_superclass

#

_类 '{0}' 不能扩展 '{1}'，因为 '{1}' 只有工厂构造函数（没有生成式构造函数），而 '{0}'#### 说明

当在实例方法之外使用关键字 super 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 super 用于顶级函数中：

dart
void f() {
  super.f();
}

常规修复

#

重写代码以不使用 super 。

super_in_redirecting_constructor

#

重定向构造函数不能有 'super' 初始化器。

说明

#

当重定向到另一个构造函数的构造函数也尝试调用超类的构造函数时，分析器会生成此诊断信息。当调用重定向构造函数重定向到的构造函数时，将调用超类构造函数。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 同时重定向到 C.b 并调用超类的构造函数：

dart
class C {
  C.a() : this.b(), super();
  C.b();
}

常规修复

#

删除 super 构造函数的调用：

dart
class C {
  C.a() : this.b();
  C.b();
}

switch_case_completes_normally

#

'case' 不应正常完成。

说明

#

当 switch 语句中 case 标签后的语句可能贯穿到下一个 case 或 default 标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值为零 (0) 的 case 标签贯穿到 default 语句：

dart
void f(int a) {
  switch (a) {
    case 0:
      print(0);
    default:
      return;
  }
}

常规修复

#

更改控制流，以便 case 不会贯穿。这可以通过在当前语句列表的末尾添加以下内容之一来完成：

  • 一个 return 语句，
  • 一个 throw 表达式，
  • 一个 break 语句，
  • 一个 continue ，或
  • 一个返回类型为 Never 的函数或方法的调用。

switch_expression_not_assignable

#

switch 表达式的类型 '{0}' 无法赋值给 case 表达式的类型 '{1}'。

说明

#

当 switch 语句中的表达式的类型无法赋值给 case 子句中表达式的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 s 的类型（ String ）无法赋值给 0 的类型（ int ）：

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

常规修复

#

如果 case 表达式的类型正确，则更改 switch 语句中的表达式使其具有正确的类型：

dart
void f(String s) {
  switch (int.parse(s)) {
    case 0:
      break;
  }
}

如果 switch 表达式的类型正确，则更改 case 表达式使其具有正确的类型：

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

tearoff_of_generative_constructor_of_abstract_class

#

不能分离抽象类的生成式构造函数。

说明

#

当从抽象类中分离生成式构造函数时，分析器会生成此诊断信息。这是不允许的，因为实例化抽象类是无效的，这意味着分离的构造函数没有有效的用途。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.new 正在被分离，而类 C 是抽象类：

dart
abstract class C {
  C();
}

void f() {
  C.new;
}

常规修复

#

分离具体类的构造函数。

text_direction_code_point_in_comment

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

text_direction_code_point_in_literal

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

throw_of_invalid_type

#

抛出表达式的类型 '{0}' 必须可赋值为 'Object'。

说明

#

当 throw 表达式中的表达式的类型无法赋值给 Object 时，分析器会生成此诊断信息。抛出 null 是无效的，因此使用可能计算为 null 的表达式也是无效的。

示例

#

以下代码会生成此诊断信息，因为 s 可能为 null ：

dart
void f(String? s) {
  throw s;
}

常规修复

#

向表达式添加显式的空检查：

dart
void f(String? s) {
  throw s!;
}

top_level_cycle

#

无法推断 '{0}' 的类型，因为它通过循环依赖自身：{1}。

说明

#

当顶级变量没有类型注解，并且变量的初始化器直接或间接引用该变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 x 和 y 是根据彼此定义的，并且两者都没有显式类型，因此无法推断另一个的类型：

dart
var x = y;
var y = x;

常规修复

#

如果这两个变量不需要相互引用，则打破循环：

dart
var x = 0;
var y = x;

如果这两个变量需要相互引用，则至少为其中一个变量提供显式类型：

dart
int x = y;
var y = x;

但是，请注意，虽然此代码不会生成任何诊断信息，但除非在循环中的任何变量被引用之前，至少为一个变量赋值一个不依赖于其他变量的值，否则它会在运行时产生堆栈溢出。

type_alias_cannot_reference_itself

#

typedef 不能直接或通过另一个 typedef 递归地引用自身。

说明

#

当 typedef 直接或间接引用自身时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 通过 G 间接依赖于自身：

dart
typedef F = void Function(G);
typedef G = void Function(F);

常规修复

#

更改循环中的一个或多个 typedef，使它们都不引用自身：

dart
typedef F = void Function(G);
typedef G = void Function(int);

type_annotation_deferred_class

#

延迟加载类型 '{0}' 不能用于声明、强制转换或类型测试中。

说明

#

当类型注解位于变量声明中，或者在强制转换 (as) 或类型测试 (is) 中使用的类型是在使用延迟导入导入的库中声明的类型时，分析器会生成此诊断信息。这些类型需要在编译时可用，但不可用。

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

示例

#

以下代码会生成此诊断信息，因为参数 f 的类型是从延迟加载库导入的：

dart
import 'dart:io' deferred as io;

void f(io.File f) {}

常规修复

#

如果您需要引用导入的类型，则删除 deferred 关键字：

dart
import 'dart:io' as io;

void f(io.File f) {}

如果需要延迟导入，并且还有其他合适的类型，则使用该类型代替延迟加载库中的类型。

type_argument_not_matching_bounds

#

' {0}' 不符合类型参数 '{1}' 的边界 '{2}'。

说明

#

当类型参数不是相同类型或其对应类型参数的子类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 不是 num 的子类：

dart
class A<E extends num> {}

var a = A<String>();

常规修复

#

将类型参数更改为边界的子类：

dart
class A<E extends num> {}

var a = A<int>();

type_check_with_null

#

对非空的测试应使用 '!= null' 进行。

对 null 的测试应使用 '== null' 进行。

说明

#

当类型检查（使用 as 运算符）的类型为 Null 时，分析器会生成此诊断信息。只有一个值为 Null 类型，因此当显式测试 null 时，代码的可读性和性能都会更好。

示例

#

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为 null ：

dart
void f(String? s) {
  if (s is Null) {
    return;
  }
  print(s);
}

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为非 null ：

dart
void f(String? s) {
  if (s is! Null) {
    print(s);
  }
}

常规修复

#

将类型检查替换为与 null 的等效比较：

dart
void f(String? s) {
  if (s == null) {
    return;
  }
  print(s);
}

type_parameter_referenced_by_static

#

静态成员不能引用类的类型参数。

说明

#

当静态成员引用为类声明的类型参数时，分析器会生成此诊断信息。类型参数仅对类的实例有意义。

示例

#

以下代码会生成此诊断信息，因为静态方法 hasType 引用了类型参数 T ：

dart
class C<T> {
  static bool hasType(Object o) => o is T;
}

常规修复

#

如果成员可以是实例成员，则删除关键字 static ：

dart
class C<T> {
  bool hasType(Object o) => o is T;
}

如果成员必须是静态成员，则使成员成为泛型：

dart
class C<T> {
  static bool hasType<S>(Object o) => o is S;
}

但是，请注意， T 和 S 之间没有关系，因此第二个选项会更改与可能预期的语义。

type_parameter_supertype_of_its_bound

#

' {0}' 不能是其上限的超类型。

说明

#

当类型参数的边界（ extends 关键字后的类型）直接或间接为类型参数本身时，分析器会生成此诊断信息。声明类型参数必须与自身相同是没有意义的。

示例

#

以下代码会生成此诊断信息，因为 T 的边界是 T ：

dart
class C<T extends T> {}

以下代码会生成此诊断信息，因为 T1 的边界是 T2 ，而 T2 的边界是 T1 ，有效地使 T1 的边界为 T1 ：

dart
class C<T1 extends T2, T2 extends T1> {}

常规修复

#

如果类型参数需要是某种类型的子类，则用所需的类型替换边界：

dart
class C<T extends num> {}

如果类型参数可以是任何类型，则删除 extends 子句：

dart
class C<T> {}

type_test_with_non_type

#

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

说明

#

当 is 或 is! 测试的右侧不是类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为右侧是参数，而不是类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is b) {
    return;
  }
}

常规修复

#

如果您打算使用类型测试，则将右侧替换为类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is B) {
    return;
  }
}

如果您打算使用其他类型的测试，则更改测试：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a == b) {
    return;
  }
}

type_test_with_undefined_name

#

名称 '{0}' 未定义，因此不能在 'is' 表达式中使用。

说明

#

当类型测试表达式中的 is 后的名称未定义时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 Srting 未定义：

dart
void f(Object o) {
  if (o is Srting) {
    // ...
  }
}

常规修复

#

将名称替换为类型的名称：

dart
void f(Object o) {
  if (o is String) {
    // ...
  }
}

unchecked_use_of_nullable_value

#

可空表达式不能用作条件。

可空表达式不能用作 for-in 循环中的迭代器。

可空表达式不能用于展开中。

可空表达式不能用于 yield-each 语句中。

由于函数可能为 'null'，因此不能无条件调用该函数。

由于接收者可能为 'null'，因此不能无条件调用方法 '{0}'。

由于接收者可能为 'null'，因此不能无条件调用运算符 '{0}'。

由于接收者可能为 'null'，因此不能无条件访问属性 '{0}'。

说明

#

当在不首先验证值是否为 null 的情况下取消引用类型为 潜在的非空类型 的表达式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为在引用 s 时， s 可能为 null ：

dart
void f(String? s) {
  if (s.length > 3) {
    // ...
  }
}

常规修复

#

如果该值确实可以为 null ，则添加一个测试以确保只有在该值不为 null 时才访问成员：

dart
void f(String? s) {
  if (s != null && s.length > 3) {
    // ...
  }
}

如果该表达式是变量，并且该值绝不应为 null ，则将变量的类型更改为非空：

dart
void f(String s) {
  if (s.length > 3) {
    // ...
  }
}

如果您认为表达式的值绝不应为 null ，但您无法更改变量的类型，并且您愿意承担如果出错则在运行时抛出异常的风险，则可以断言该值不为 null：

dart
void f(String? s) {
  if (s!.length > 3) {
    // ...
  }
}

undefined_annotation

#

用作注解的未定义名称 '{0}'。

说明

#

当使用未定义的名称作为注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 undefined 未定义：

dart
@undefined
void f() {}

常规修复

#

如果名称正确，但尚未声明，则将其声明为常量值：

dart
const undefined = 'undefined';

@undefined
void f() {}

如果名称错误，则将名称替换为有效常量的名称：

dart
@deprecated
void f() {}

否则，删除注解。

undefined_class

#

未定义的类 '{0}'。

说明

#

当遇到看起来像是类的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 Piont 未定义：

dart
class Point {}

void f(Piont p) {}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的类的名称。可以通过修复类的拼写来更正上面的示例：

dart
class Point {}

void f(Point p) {}

如果已定义该类但不可见，则可能需要添加导入。

undefined_constructor_in_initializer

#

类 '{0}' 没有名为 '{1}' 的构造函数。

类 '{0}' 没有未命名的构造函数。

说明

#

当在构造函数的初始化器列表中调用超类构造函数，但超类没有定义正在调用的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 没有未命名的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super();
}

以下代码会生成此诊断信息，因为 A 没有名为 m 的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.m();
}

常规修复

#

如果超类定义了应调用的构造函数，则更改正在调用的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.n();
}

如果超类没有定义合适的构造函数，则定义正在调用的构造函数：

dart
class A {
  A.m();
  A.n();
}
class B extends A {
  B() : super.m();
}

undefined_enum_constant

#

'{1}' 中没有名为 '{0}' 的常量。

说明

#

当遇到看起来像是枚举值的名称的标识符，并且该名称在其被引用的作用域中未定义或不可见时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 E 没有定义名为 c 的常量：

dart
enum E {a, b}

var e = E.c;

常规修复

#

如果应定义该常量，则将其添加到枚举的声明中：

dart
enum E {a, b, c}

var e = E.c;

如果常量不应定义，则将名称更改为现有常量的名称：

dart
enum E {a, b}

var e = E.b;

undefined_enum_constructor

#

枚举没有名为 '{0}' 的构造函数。

枚举没有未命名的构造函数。

说明

#

当调用用于初始化枚举值的构造函数不存在时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为枚举值 c 由未命名的构造函数初始化，但在 E 中没有定义未命名的构造函数：

dart
enum E {
  c() ;

  const E.x();
}

以下代码会生成此诊断信息，因为枚举值 c 由名为 x 的构造函数初始化，但在 E 中没有定义名为 x 的构造函数：

dart
enum E {
  c. x() ;

  const E.y();
}

常规修复

#

如果枚举值由未命名的构造函数初始化，并且应使用命名构造函数之一，则添加构造函数的名称：

dart
enum E {
  c.x();

  const E.x();
}

如果枚举值由未命名的构造函数初始化，并且命名构造函数都不合适，则定义未命名的构造函数：

dart
enum E {
  c();

  const E();
}

如果枚举值由命名的构造函数初始化，并且现有的构造函数之一应已被使用，则更改正在调用的构造函数的名称（或者如果应使用未命名的构造函数，则将其删除）：

dart
enum E {
  c.y();

  const E();
  const E.y();
}

如果枚举值由命名的构造函数初始化，并且现有构造函数都不应使用，则定义一个具有所用名称的构造函数：

dart
enum E {
  c.x();

  const E.x();
}

undefined_extension_getter

#

扩展 '{1}' 没有定义 getter '{0}'。

说明

#

当使用扩展重写调用 getter，但指定的扩展没有定义该 getter 时，分析器会生成此诊断信息。当引用静态 getter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 getter：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 getter：

dart
extension E on String {}

var x = E.a;

常规修复

#

如果 getter 的名称不正确，则将其更改为现有 getter 的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').a;
}

如果 getter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  F('c').b;
}

如果 getter 和扩展的名称都正确，但未定义 getter，则定义 getter：

dart
extension E on String {
  String get a => 'a';
  String get b => 'z';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

undefined_extension_method

#

扩展 '{1}' 没有定义方法 '{0}'。

说明

#

当使用扩展重写调用方法，但指定的扩展没有定义该方法时，分析器会生成此诊断信息。当引用静态方法但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例方法：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c'). b() ;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态方法：

dart
extension E on String {}

var x = E. a() ;

常规修复

#

如果方法的名称不正确，则将其更改为现有方法的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').a();
}

如果方法的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  F('c').b();
}

如果方法和扩展的名称都正确，但未定义该方法，则定义该方法：

dart
extension E on String {
  String a() => 'a';
  String b() => 'z';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').b();
}

undefined_extension_operator

#

扩展 '{1}' 没有定义运算符 '{0}'。

说明

#

当在特定扩展上调用运算符时，该扩展没有实现该运算符，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有定义运算符 * ：

dart
var x = E('') * 4;

extension E on String {}

常规修复

#

如果扩展预计要实现该运算符，则向扩展中添加运算符的实现：

dart
var x = E('') * 4;

extension E on String {
  int operator *(int multiplier) => length * multiplier;
}

如果运算符由不同的扩展定义，则将扩展的名称更改为定义运算符的扩展的名称。

如果运算符在扩展重写的参数上定义，则删除扩展重写：

dart
var x = '' * 4;

extension E on String {}

undefined_extension_setter

#

扩展 '{1}' 没有定义 setter '{0}'。

说明

#

当使用扩展重写调用 setter，但指定的扩展没有定义该 setter 时，分析器会生成此诊断信息。当引用静态 setter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 setter：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 setter：

dart
extension E on String {}

void f() {
  E.a = 3;
}

常规修复

#

如果 setter 的名称不正确，则将其更改为现有 setter 的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').a = 'd';
}

如果 setter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  F('c').b = 'd';
}

如果 setter 和扩展的名称都正确，但未定义 setter，则定义 setter：

dart
extension E on String {
  set a(String v) {}
  set b(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

undefined_function

#

函数 '{0}' 未定义。

说明

#

当遇到看起来像是函数的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 emty 未定义：

dart
List<int> empty() => [];

void main() {
  print(emty());
}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的函数的名称。可以通过修复函数的拼写来更正上面的示例：

dart
List<int> empty() => [];

void main() {
  print(empty());
}

如果已定义该函数但不可见，则可能需要添加导入或重新排列代码以使该函数可见。

undefined_getter

#

getter '{0}' 未在 '{1}' 函数类型中定义。

getter '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是 getter 的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 没有名为 len 的成员：

dart
int f(String s) => s.len;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的 getter 的名称。可以通过修复 getter 的拼写来更正上面的示例：

dart
int f(String s) => s.length;

undefined_hidden_name

#

库 '{0}' 没有导出具有隐藏名称 '{1}' 的成员。

说明

#

当隐藏组合器包含未由导入的库定义的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:math 没有定义名称 String ：

dart
import 'dart:math' hide String, max;

var x = min(0, 1);

常规修复

#

如果应隐藏不同的名称，则更正名称。否则，从列表中删除名称：

dart
import 'dart:math' hide max;

var x = min(0, 1);

undefined_identifier

#

未定义的名称 '{0}'。

说明

#

当遇到未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 rihgt 未定义：

dart
int min(int left, int right) => left <= rihgt ? left : right;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的标识符。可以通过修复变量的拼写来更正上面的示例：

dart
int min(int left, int right) => left <= right ? left : right;

如果已定义标识符但不可见，则可能需要添加导入或重新排列代码以使标识符可见。

undefined_identifier_await

#

在未用 'async' 标记的函数体中未定义名称 'await'。

说明

#

当在方法或函数体中使用名称 await 但未声明，并且主体未用 async 关键字标记时，分析器会生成此诊断信息。名称 await 仅在异步函数中引入 await 表达式。

示例

#

以下代码会生成此诊断信息，因为名称 await 用于 f 的主体中，即使 f 的主体未用 async 关键字标记：

dart
void f(p) { await p; }

常规修复

#

向函数体添加关键字 async ：

dart
void f(p) async { await p; }

undefined_method

#

方法 '{0}' 未在 '{1}' 函数类型中定义。

方法 '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是方法的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标识符 removeMiddle 未定义：

dart
int f(List<int> l) => l. removeMiddle() ;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的方法的名称。可以通过修复方法的拼写来更正上面的示例：

dart
int f(List<int> l) => l.removeLast();

undefined_named_parameter

#

命名参数 '{0}' 未定义。

说明

#

当方法或函数调用具有命名参数，但正在调用的方法或函数没有定义具有相同名称的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 没有声明名为 a 的命名参数：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

常规修复

#

如果参数名称键入错误，则将其替换为正确的名称。可以通过将 a 更改为 b 来修复上面的示例：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(b: 1);
}

如果子类添加了一个具有该名称的参数，则将接收者强制转换为子类：

dart
class C {
  m({int? b}) {}
}

class D extends C {
  m({int? a, int? b}) {}
}

void f(C c) {
  (c as D).m(a: 1);
}

如果应将参数添加到函数，则添加它：

dart
class C {
  m({int? a, int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

undefined_operator

#

运算符 '{0}' 未在类型 '{1}' 中定义。

说明

#

当#### 说明

当在实例方法之外使用关键字 super 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 super 用于顶级函数中：

dart
void f() {
  super.f();
}

常规修复

#

重写代码以不使用 super 。

super_in_redirecting_constructor

#

重定向构造函数不能有 'super' 初始化器。

说明

#

当重定向到另一个构造函数的构造函数也尝试调用超类的构造函数时，分析器会生成此诊断信息。当调用重定向构造函数重定向到的构造函数时，将调用超类构造函数。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 同时重定向到 C.b 并调用超类的构造函数：

dart
class C {
  C.a() : this.b(), super();
  C.b();
}

常规修复

#

删除 super 构造函数的调用：

dart
class C {
  C.a() : this.b();
  C.b();
}

switch_case_completes_normally

#

'case' 不应正常完成。

说明

#

当 switch 语句中 case 标签后的语句可能贯穿到下一个 case 或 default 标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值为零 (0) 的 case 标签贯穿到 default 语句：

dart
void f(int a) {
  switch (a) {
    case 0:
      print(0);
    default:
      return;
  }
}

常规修复

#

更改控制流，以便 case 不会贯穿。这可以通过在当前语句列表的末尾添加以下内容之一来完成：

  • 一个 return 语句，
  • 一个 throw 表达式，
  • 一个 break 语句，
  • 一个 continue ，或
  • 一个返回类型为 Never 的函数或方法的调用。

switch_expression_not_assignable

#

switch 表达式的类型 '{0}' 无法赋值给 case 表达式的类型 '{1}'。

说明

#

当 switch 语句中的表达式的类型无法赋值给 case 子句中表达式的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 s 的类型（ String ）无法赋值给 0 的类型（ int ）：

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

常规修复

#

如果 case 表达式的类型正确，则更改 switch 语句中的表达式使其具有正确的类型：

dart
void f(String s) {
  switch (int.parse(s)) {
    case 0:
      break;
  }
}

如果 switch 表达式的类型正确，则更改 case 表达式使其具有正确的类型：

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

tearoff_of_generative_constructor_of_abstract_class

#

不能分离抽象类的生成式构造函数。

说明

#

当从抽象类中分离生成式构造函数时，分析器会生成此诊断信息。这是不允许的，因为实例化抽象类是无效的，这意味着分离的构造函数没有有效的用途。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.new 正在被分离，而类 C 是抽象类：

dart
abstract class C {
  C();
}

void f() {
  C.new;
}

常规修复

#

分离具体类的构造函数。

text_direction_code_point_in_comment

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

text_direction_code_point_in_literal

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

throw_of_invalid_type

#

抛出表达式的类型 '{0}' 必须可赋值为 'Object'。

说明

#

当 throw 表达式中的表达式的类型无法赋值给 Object 时，分析器会生成此诊断信息。抛出 null 是无效的，因此使用可能计算为 null 的表达式也是无效的。

示例

#

以下代码会生成此诊断信息，因为 s 可能为 null ：

dart
void f(String? s) {
  throw s;
}

常规修复

#

向表达式添加显式的空检查：

dart
void f(String? s) {
  throw s!;
}

top_level_cycle

#

无法推断 '{0}' 的类型，因为它通过循环依赖自身：{1}。

说明

#

当顶级变量没有类型注解，并且变量的初始化器直接或间接引用该变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 x 和 y 是根据彼此定义的，并且两者都没有显式类型，因此无法推断另一个的类型：

dart
var x = y;
var y = x;

常规修复

#

如果这两个变量不需要相互引用，则打破循环：

dart
var x = 0;
var y = x;

如果这两个变量需要相互引用，则至少为其中一个变量提供显式类型：

dart
int x = y;
var y = x;

但是，请注意，虽然此代码不会生成任何诊断信息，但除非在循环中的任何变量被引用之前，至少为一个变量赋值一个不依赖于其他变量的值，否则它会在运行时产生堆栈溢出。

type_alias_cannot_reference_itself

#

typedef 不能直接或通过另一个 typedef 递归地引用自身。

说明

#

当 typedef 直接或间接引用自身时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 通过 G 间接依赖于自身：

dart
typedef F = void Function(G);
typedef G = void Function(F);

常规修复

#

更改循环中的一个或多个 typedef，使它们都不引用自身：

dart
typedef F = void Function(G);
typedef G = void Function(int);

type_annotation_deferred_class

#

延迟加载类型 '{0}' 不能用于声明、强制转换或类型测试中。

说明

#

当类型注解位于变量声明中，或者在强制转换 (as) 或类型测试 (is) 中使用的类型是在使用延迟导入导入的库中声明的类型时，分析器会生成此诊断信息。这些类型需要在编译时可用，但不可用。

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

示例

#

以下代码会生成此诊断信息，因为参数 f 的类型是从延迟加载库导入的：

dart
import 'dart:io' deferred as io;

void f(io.File f) {}

常规修复

#

如果您需要引用导入的类型，则删除 deferred 关键字：

dart
import 'dart:io' as io;

void f(io.File f) {}

如果需要延迟导入，并且还有其他合适的类型，则使用该类型代替延迟加载库中的类型。

type_argument_not_matching_bounds

#

' {0}' 不符合类型参数 '{1}' 的边界 '{2}'。

说明

#

当类型参数不是相同类型或其对应类型参数的子类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 不是 num 的子类：

dart
class A<E extends num> {}

var a = A<String>();

常规修复

#

将类型参数更改为边界的子类：

dart
class A<E extends num> {}

var a = A<int>();

type_check_with_null

#

对非空的测试应使用 '!= null' 进行。

对 null 的测试应使用 '== null' 进行。

说明

#

当类型检查（使用 as 运算符）的类型为 Null 时，分析器会生成此诊断信息。只有一个值为 Null 类型，因此当显式测试 null 时，代码的可读性和性能都会更好。

示例

#

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为 null ：

dart
void f(String? s) {
  if (s is Null) {
    return;
  }
  print(s);
}

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为非 null ：

dart
void f(String? s) {
  if (s is! Null) {
    print(s);
  }
}

常规修复

#

将类型检查替换为与 null 的等效比较：

dart
void f(String? s) {
  if (s == null) {
    return;
  }
  print(s);
}

type_parameter_referenced_by_static

#

静态成员不能引用类的类型参数。

说明

#

当静态成员引用为类声明的类型参数时，分析器会生成此诊断信息。类型参数仅对类的实例有意义。

示例

#

以下代码会生成此诊断信息，因为静态方法 hasType 引用了类型参数 T ：

dart
class C<T> {
  static bool hasType(Object o) => o is T;
}

常规修复

#

如果成员可以是实例成员，则删除关键字 static ：

dart
class C<T> {
  bool hasType(Object o) => o is T;
}

如果成员必须是静态成员，则使成员成为泛型：

dart
class C<T> {
  static bool hasType<S>(Object o) => o is S;
}

但是，请注意， T 和 S 之间没有关系，因此第二个选项会更改与可能预期的语义。

type_parameter_supertype_of_its_bound

#

' {0}' 不能是其上限的超类型。

说明

#

当类型参数的边界（ extends 关键字后的类型）直接或间接为类型参数本身时，分析器会生成此诊断信息。声明类型参数必须与自身相同是没有意义的。

示例

#

以下代码会生成此诊断信息，因为 T 的边界是 T ：

dart
class C<T extends T> {}

以下代码会生成此诊断信息，因为 T1 的边界是 T2 ，而 T2 的边界是 T1 ，有效地使 T1 的边界为 T1 ：

dart
class C<T1 extends T2, T2 extends T1> {}

常规修复

#

如果类型参数需要是某种类型的子类，则用所需的类型替换边界：

dart
class C<T extends num> {}

如果类型参数可以是任何类型，则删除 extends 子句：

dart
class C<T> {}

type_test_with_non_type

#

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

说明

#

当 is 或 is! 测试的右侧不是类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为右侧是参数，而不是类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is b) {
    return;
  }
}

常规修复

#

如果您打算使用类型测试，则将右侧替换为类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is B) {
    return;
  }
}

如果您打算使用其他类型的测试，则更改测试：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a == b) {
    return;
  }
}

type_test_with_undefined_name

#

名称 '{0}' 未定义，因此不能在 'is' 表达式中使用。

说明

#

当类型测试表达式中的 is 后的名称未定义时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 Srting 未定义：

dart
void f(Object o) {
  if (o is Srting) {
    // ...
  }
}

常规修复

#

将名称替换为类型的名称：

dart
void f(Object o) {
  if (o is String) {
    // ...
  }
}

unchecked_use_of_nullable_value

#

可空表达式不能用作条件。

可空表达式不能用作 for-in 循环中的迭代器。

可空表达式不能用于展开中。

可空表达式不能用于 yield-each 语句中。

由于函数可能为 'null'，因此不能无条件调用该函数。

由于接收者可能为 'null'，因此不能无条件调用方法 '{0}'。

由于接收者可能为 'null'，因此不能无条件调用运算符 '{0}'。

由于接收者可能为 'null'，因此不能无条件访问属性 '{0}'。

说明

#

当在不首先验证值是否为 null 的情况下取消引用类型为 潜在的非空类型 的表达式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为在引用 s 时， s 可能为 null ：

dart
void f(String? s) {
  if (s.length > 3) {
    // ...
  }
}

常规修复

#

如果该值确实可以为 null ，则添加一个测试以确保只有在该值不为 null 时才访问成员：

dart
void f(String? s) {
  if (s != null && s.length > 3) {
    // ...
  }
}

如果该表达式是变量，并且该值绝不应为 null ，则将变量的类型更改为非空：

dart
void f(String s) {
  if (s.length > 3) {
    // ...
  }
}

如果您认为表达式的值绝不应为 null ，但您无法更改变量的类型，并且您愿意承担如果出错则在运行时抛出异常的风险，则可以断言该值不为 null：

dart
void f(String? s) {
  if (s!.length > 3) {
    // ...
  }
}

undefined_annotation

#

用作注解的未定义名称 '{0}'。

说明

#

当使用未定义的名称作为注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 undefined 未定义：

dart
@undefined
void f() {}

常规修复

#

如果名称正确，但尚未声明，则将其声明为常量值：

dart
const undefined = 'undefined';

@undefined
void f() {}

如果名称错误，则将名称替换为有效常量的名称：

dart
@deprecated
void f() {}

否则，删除注解。

undefined_class

#

未定义的类 '{0}'。

说明

#

当遇到看起来像是类的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 Piont 未定义：

dart
class Point {}

void f(Piont p) {}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的类的名称。可以通过修复类的拼写来更正上面的示例：

dart
class Point {}

void f(Point p) {}

如果已定义该类但不可见，则可能需要添加导入。

undefined_constructor_in_initializer

#

类 '{0}' 没有名为 '{1}' 的构造函数。

类 '{0}' 没有未命名的构造函数。

说明

#

当在构造函数的初始化器列表中调用超类构造函数，但超类没有定义正在调用的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 没有未命名的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super();
}

以下代码会生成此诊断信息，因为 A 没有名为 m 的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.m();
}

常规修复

#

如果超类定义了应调用的构造函数，则更改正在调用的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.n();
}

如果超类没有定义合适的构造函数，则定义正在调用的构造函数：

dart
class A {
  A.m();
  A.n();
}
class B extends A {
  B() : super.m();
}

undefined_enum_constant

#

'{1}' 中没有名为 '{0}' 的常量。

说明

#

当遇到看起来像是枚举值的名称的标识符，并且该名称在其被引用的作用域中未定义或不可见时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 E 没有定义名为 c 的常量：

dart
enum E {a, b}

var e = E.c;

常规修复

#

如果应定义该常量，则将其添加到枚举的声明中：

dart
enum E {a, b, c}

var e = E.c;

如果常量不应定义，则将名称更改为现有常量的名称：

dart
enum E {a, b}

var e = E.b;

undefined_enum_constructor

#

枚举没有名为 '{0}' 的构造函数。

枚举没有未命名的构造函数。

说明

#

当调用用于初始化枚举值的构造函数不存在时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为枚举值 c 由未命名的构造函数初始化，但在 E 中没有定义未命名的构造函数：

dart
enum E {
  c() ;

  const E.x();
}

以下代码会生成此诊断信息，因为枚举值 c 由名为 x 的构造函数初始化，但在 E 中没有定义名为 x 的构造函数：

dart
enum E {
  c. x() ;

  const E.y();
}

常规修复

#

如果枚举值由未命名的构造函数初始化，并且应使用命名构造函数之一，则添加构造函数的名称：

dart
enum E {
  c.x();

  const E.x();
}

如果枚举值由未命名的构造函数初始化，并且命名构造函数都不合适，则定义未命名的构造函数：

dart
enum E {
  c();

  const E();
}

如果枚举值由命名的构造函数初始化，并且现有的构造函数之一应已被使用，则更改正在调用的构造函数的名称（或者如果应使用未命名的构造函数，则将其删除）：

dart
enum E {
  c.y();

  const E();
  const E.y();
}

如果枚举值由命名的构造函数初始化，并且现有构造函数都不应使用，则定义一个具有所用名称的构造函数：

dart
enum E {
  c.x();

  const E.x();
}

undefined_extension_getter

#

扩展 '{1}' 没有定义 getter '{0}'。

说明

#

当使用扩展重写调用 getter，但指定的扩展没有定义该 getter 时，分析器会生成此诊断信息。当引用静态 getter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 getter：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 getter：

dart
extension E on String {}

var x = E.a;

常规修复

#

如果 getter 的名称不正确，则将其更改为现有 getter 的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').a;
}

如果 getter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  F('c').b;
}

如果 getter 和扩展的名称都正确，但未定义 getter，则定义 getter：

dart
extension E on String {
  String get a => 'a';
  String get b => 'z';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

undefined_extension_method

#

扩展 '{1}' 没有定义方法 '{0}'。

说明

#

当使用扩展重写调用方法，但指定的扩展没有定义该方法时，分析器会生成此诊断信息。当引用静态方法但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例方法：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c'). b() ;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态方法：

dart
extension E on String {}

var x = E. a() ;

常规修复

#

如果方法的名称不正确，则将其更改为现有方法的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').a();
}

如果方法的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  F('c').b();
}

如果方法和扩展的名称都正确，但未定义该方法，则定义该方法：

dart
extension E on String {
  String a() => 'a';
  String b() => 'z';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').b();
}

undefined_extension_operator

#

扩展 '{1}' 没有定义运算符 '{0}'。

说明

#

当在特定扩展上调用运算符时，该扩展没有实现该运算符，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有定义运算符 * ：

dart
var x = E('') * 4;

extension E on String {}

常规修复

#

如果扩展预计要实现该运算符，则向扩展中添加运算符的实现：

dart
var x = E('') * 4;

extension E on String {
  int operator *(int multiplier) => length * multiplier;
}

如果运算符由不同的扩展定义，则将扩展的名称更改为定义运算符的扩展的名称。

如果运算符在扩展重写的参数上定义，则删除扩展重写：

dart
var x = '' * 4;

extension E on String {}

undefined_extension_setter

#

扩展 '{1}' 没有定义 setter '{0}'。

说明

#

当使用扩展重写调用 setter，但指定的扩展没有定义该 setter 时，分析器会生成此诊断信息。当引用静态 setter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 setter：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 setter：

dart
extension E on String {}

void f() {
  E.a = 3;
}

常规修复

#

如果 setter 的名称不正确，则将其更改为现有 setter 的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').a = 'd';
}

如果 setter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  F('c').b = 'd';
}

如果 setter 和扩展的名称都正确，但未定义 setter，则定义 setter：

dart
extension E on String {
  set a(String v) {}
  set b(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

undefined_function

#

函数 '{0}' 未定义。

说明

#

当遇到看起来像是函数的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 emty 未定义：

dart
List<int> empty() => [];

void main() {
  print(emty());
}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的函数的名称。可以通过修复函数的拼写来更正上面的示例：

dart
List<int> empty() => [];

void main() {
  print(empty());
}

如果已定义该函数但不可见，则可能需要添加导入或重新排列代码以使该函数可见。

undefined_getter

#

getter '{0}' 未在 '{1}' 函数类型中定义。

getter '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是 getter 的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 没有名为 len 的成员：

dart
int f(String s) => s.len;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的 getter 的名称。可以通过修复 getter 的拼写来更正上面的示例：

dart
int f(String s) => s.length;

undefined_hidden_name

#

库 '{0}' 没有导出具有隐藏名称 '{1}' 的成员。

说明

#

当隐藏组合器包含未由导入的库定义的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:math 没有定义名称 String ：

dart
import 'dart:math' hide String, max;

var x = min(0, 1);

常规修复

#

如果应隐藏不同的名称，则更正名称。否则，从列表中删除名称：

dart
import 'dart:math' hide max;

var x = min(0, 1);

undefined_identifier

#

未定义的名称 '{0}'。

说明

#

当遇到未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 rihgt 未定义：

dart
int min(int left, int right) => left <= rihgt ? left : right;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的标识符。可以通过修复变量的拼写来更正上面的示例：

dart
int min(int left, int right) => left <= right ? left : right;

如果已定义标识符但不可见，则可能需要添加导入或重新排列代码以使标识符可见。

undefined_identifier_await

#

在未用 'async' 标记的函数体中未定义名称 'await'。

说明

#

当在方法或函数体中使用名称 await 但未声明，并且主体未用 async 关键字标记时，分析器会生成此诊断信息。名称 await 仅在异步函数中引入 await 表达式。

示例

#

以下代码会生成此诊断信息，因为名称 await 用于 f 的主体中，即使 f 的主体未用 async 关键字标记：

dart
void f(p) { await p; }

常规修复

#

向函数体添加关键字 async ：

dart
void f(p) async { await p; }

undefined_method

#

方法 '{0}' 未在 '{1}' 函数类型中定义。

方法 '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是方法的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标识符 removeMiddle 未定义：

dart
int f(List<int> l) => l. removeMiddle() ;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的方法的名称。可以通过修复方法的拼写来更正上面的示例：

dart
int f(List<int> l) => l.removeLast();

undefined_named_parameter

#

命名参数 '{0}' 未定义。

说明

#

当方法或函数调用具有命名参数，但正在调用的方法或函数没有定义具有相同名称的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 没有声明名为 a 的命名参数：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

常规修复

#

如果参数名称键入错误，则将其替换为正确的名称。可以通过将 a 更改为 b 来修复上面的示例：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(b: 1);
}

如果子类添加了一个具有该名称的参数，则将接收者强制转换为子类：

dart
class C {
  m({int? b}) {}
}

class D extends C {
  m({int? a, int? b}) {}
}

void f(C c) {
  (c as D).m(a: 1);
}

如果应将参数添加到函数，则添加它：

dart
class C {
  m({int? a, int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

undefined_operator

#

运算符 '{0}' 未在类型 '{1}' 中定义。

说明

#

当#### 说明

当类型检查（使用 is 或 is! ）的值在编译时已知时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为测试 a is Object? 始终为 true ：

dart
bool f<T>(T a) => a is Object?;

常规修复

#

如果类型检查没有检查您想要检查的内容，则更改测试：

dart
bool f<T>(T a) => a is Object;

如果类型检查确实检查了您想要检查的内容，则将类型检查替换为其已知值或将其完全删除：

dart
bool f<T>(T a) => true;

unqualified_reference_to_non_local_static_member

#

超类型中的静态 {1} '{0}' 不能通过实例访问。

说明

#

当一个类中的代码引用超类中的静态成员，而没有在成员名称前加上超类的名称时，分析器会生成此诊断信息。静态成员只能在其声明的类中无前缀地引用。

示例

#

以下代码会生成此诊断信息，因为静态字段 x 在 getter g 中被引用，而没有在它前面加上定义类的名称：

dart
class A {
  static int x = 3;
}

class B extends A {
  int get g => x;
}

常规修复

#

在静态成员的名称前加上声明类的名称：

dart
class A {
  static int x = 3;
}

class B extends A {
  int get g => A.x;
}

unqualified_reference_to_static_member_of_extended_type

#

扩展类型或其超类之一中的静态成员必须由定义类型的名称限定。

说明

#

当找到未定义的名称，并且该名称与扩展类型或其超类之一的静态成员相同时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 是扩展类型 C 的静态成员：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    m() ;
  }
}

常规修复

#

如果您尝试引用在扩展之外声明的静态成员，则在对成员的引用之前添加类或扩展的名称：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    C.m();
  }
}

如果您正在引用尚未声明的成员，请添加声明：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    m();
  }

  void m() {}
}

unreachable_switch_case

#

此 case 被前面的 cases 覆盖。

说明

#

当 switch 语句中的 case 子句由于所有可匹配的值都被前面 case 子句匹配而无法匹配任何内容时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值 1 在前面的 case 中已匹配：

dart
void f(int x) {
  switch (x) {
    case 1:
      print('one');
    case 1:
      print('two');
  }
}

常规修复

#

更改一个或两个冲突的 case 以匹配不同的值：

dart
void f(int x) {
  switch (x) {
    case 1:
      print('one');
    case 2:
      print('two');
  }
}

unreachable_switch_default

#

此 default 子句被前面的 cases 覆盖。

说明

#

当 switch 语句中的 default 子句由于所有可匹配的值都被前面 case 子句匹配而无法匹配任何内容时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值 E.e1 和 E.e2 在前面的 cases 中已匹配：

dart
enum E { e1, e2 }

void f(E x) {
  switch (x) {
    case E.e1:
      print('one');
    case E.e2:
      print('two');
    default:
      print('other');
  }
}

常规修复

#

删除不必要的 default 子句：

dart
enum E { e1, e2 }
void f(E x) {
  switch (x) {
    case E.e1:
      print('one');
    case E.e2:
      print('two');
  }
}

unused_catch_clause

#

异常变量 '{0}' 未使用，因此可以删除 'catch' 子句。

说明

#

当找到 catch 子句，并且 catch 块中既未使用异常参数也未使用可选堆栈跟踪参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 e 未被引用：

dart
void f() {
  try {
    int.parse(';');
  } on FormatException catch (e) {
    // ignored
  }
}

常规修复

#

删除未使用的 catch 子句：

dart
void f() {
  try {
    int.parse(';');
  } on FormatException {
    // ignored
  }
}

unused_catch_stack

#

堆栈跟踪变量 '{0}' 未使用，可以删除。

说明

#

当 catch 子句中的堆栈跟踪参数未在 catch 块的主体中引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 stackTrace 未被引用：

dart
void f() {
  try {
    // ...
  } catch (exception, stackTrace) {
    // ...
  }
}

常规修复

#

如果您需要引用堆栈跟踪参数，则添加对它的引用。否则，将其删除：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    // ...
  }
}

unused_element

#

声明 '{0}' 未被引用。

说明

#

当私有声明在其包含声明的库中未被引用时，分析器会生成此诊断信息。将分析以下类型的声明：

  • 私有的顶级声明及其所有成员
  • 公共声明的私有成员

并非对元素的所有引用都会将其标记为“已使用”：

  • 将值赋值给顶级变量（使用标准 = 赋值或空感知 ??= 赋值）不计为使用它。
  • 在文档注释引用中引用元素不计为使用它。
  • 在 is 表达式的右侧引用类、mixin 或枚举不计为使用它。

示例

#

假设库中的任何代码都没有引用 _C ，则以下代码会生成此诊断信息：

dart
class _C {}

常规修复

#

如果不需要声明，则将其删除。

如果打算使用声明，则添加使用它的代码。

unused_element_parameter

#

从不为可选参数 '{0}' 提供值。

说明

#

当从不为私有声明中声明的可选参数传递值时，分析器会生成此诊断信息。

示例

#

假设库中的任何代码都没有在任何 _m 的调用中为 y 传递值，则以下代码会生成此诊断信息：

dart
class C {
  void _m(int x, [int? y]) {}

  void n() => _m(0);
}

常规修复

#

如果不需要声明，则将其删除：

dart
class C {
  void _m(int x) {}

  void n() => _m(0);
}

如果打算使用声明，则添加使用它的代码。

unused_field

#

字段 '{0}' 的值未使用。

说明

#

当声明私有字段但从未读取它时，即使在一个或多个地方写入它，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 _originalValue 在库中任何地方都没有被读取：

dart
class C {
  final String _originalValue;
  final String _currentValue;

  C(this._originalValue) : _currentValue = _originalValue;

  String get value => _currentValue;
}

在初始化器 (_currentValue = _originalValue) 中实际上是在引用同名参数，而不是引用该字段。

常规修复

#

如果不需要该字段，则将其删除。

如果打算使用该字段，则添加缺少的代码。

unused_import

#

未使用的导入：'{0}'。

说明

#

当导入不需要，因为导入的名称均未在导入库中引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:async 中定义的任何内容在库中都没有被引用：

dart
import 'dart:async';

void main() {}

常规修复

#

如果不需要导入，则将其删除。

如果打算使用某些导入的名称，则添加缺少的代码。

unused_label

#

标签 '{0}' 未使用。

说明

#

当找到未使用的标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标签 loop 在方法中任何地方都没有被引用：

dart
void f(int limit) {
  loop: for (int i = 0; i < limit; i++) {
    print(i);
  }
}

常规修复

#

如果不需要标签，则将其删除：

dart
void f(int limit) {
  for (int i = 0; i < limit; i++) {
    print(i);
  }
}

如果需要标签，则使用它：

dart
void f(int limit) {
  loop: for (int i = 0; i < limit; i++) {
    print(i);
    if (i != 0) {
      break loop;
    }
  }
}

unused_local_variable

#

局部变量 '{0}' 的值未使用。

说明

#

当声明局部变量但从未读取它时，即使在一个或多个地方写入它，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为从未读取 count 的值：

dart
void main() {
  int count = 0;
}

常规修复

#

如果不需要该变量，则将其删除。

如果打算使用该变量，则添加缺少的代码。

unused_result

#

' {0}' 应使用。{1}。

' {0}' 的值应使用。

说明

#

当调用用 useResult 注解注释的函数，并且未使用该函数返回的值时，分析器会生成此诊断信息。如果调用的值，如果该值传递给另一个函数，或者如果该值被赋值给变量或字段，则该值被认为是使用的。

示例

#

以下代码会生成此诊断信息，因为 c.a() 的调用未使用，即使方法 a 用 useResult 注解注释：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  c. a() ;
}

常规修复

#

如果您打算调用带注解的函数，则使用返回的值：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  print(c.a());
}

如果您打算调用不同的函数，则更正正在调用的函数的名称：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  c.b();
}

unused_shown_name

#

显示了名称 {0}，但未使用。

说明

#

当显示组合器包含未在库中使用的名称时，分析器会生成此诊断信息。因为它没有被引用，所以可以删除该名称。

示例

#

以下代码会生成此诊断信息，因为函数 max 未使用：

dart
import 'dart:math' show min, max;

var x = min(0, 1);

常规修复

#

使用该名称或将其删除：

dart
import 'dart:math' show min;

var x = min(0, 1);

uri_does_not_exist

#

URI 的目标不存在：'{0}'。

说明

#

当找到导入、导出或部分指令，并且 URI 引用不存在的文件时，分析器会生成此诊断信息。

示例

#

如果文件 lib.dart 不存在，则以下代码会生成此诊断信息：

dart
import 'lib.dart';

常规修复

#

如果 URI 键入错误或无效，则更正 URI。

如果 URI 正确，则创建该文件。

uri_does_not_exist_in_doc_import

#

URI 的目标不存在：'{0}'。

说明

#

当找到文档导入，并且 URI 引用不存在的文件时，分析器会生成此诊断信息。

示例

#

如果文件 lib.dart 不存在，则以下代码会生成此诊断信息：

dart
/// @docImport 'lib.dart';
library;

常规修复

#

如果 URI 键入错误或无效，则更正 URI。

如果 URI 正确，则创建该文件。

uri_has_not_been_generated

#

URI 的目标尚未生成：'{0}'。

说明

#

当找到导入、导出或部分指令，并且 URI 引用不存在的文件，并且文件名以代码生成器通常生成的模式结尾（例如以下模式之一）时，分析器会生成此诊断信息：

  • .g.dart
  • .pb.dart
  • .pbenum.dart
  • .pbserver.dart
  • .pbjson.dart
  • .template.dart

示例

#

如果文件 lib.g.dart 不存在，则以下代码会生成此诊断信息：

dart
import 'lib.g.dart';

常规修复

#

如果该文件是生成的文件，则运行生成该文件的生成器。

如果该文件不是生成的文件，则检查 URI 的拼写或创建该文件。

uri_with_interpolation

#

URI 不能使用字符串插值。

说明

#

当 import 、 export 或 part 指令中的字符串字面量包含插值时，分析器会生成此诊断信息。指令中 URI 的解析必须在声明编译之前发生，因此在确定 URI 的值时不能计算表达式。

示例

#

以下代码会生成此诊断信息，因为 import 指令中的字符串包含插值：

dart
import 'dart:$m';

const m = 'math';

常规修复

#

从 URI 中删除插值：

dart
import 'dart:math';

var zero = min(0, 0);

use_of_native_extension

#

Dart 本机扩展已弃用，在 Dart 2.15 中不可用。

说明

#

当使用 dart-ext 方案导入库时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为本机库 x 使用 dart-ext 方案导入：

dart
import 'dart-ext:x';

常规修复

#

重写代码以使用 dart:ffi 作为调用本机库内容的一种方式。

use_of_void_result

#

此表达式的类型为 'void'，因此其值不能使用。

说明

#

当分析器找到类型为 void 的表达式，并且该表达式在需要值的地方使用时（例如，在成员访问之前或赋值的右侧），分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 没有生成可以调用 toString 的对象：

dart
void f() {}

void g() {
  f().toString();
}

常规修复

#

重写代码使表达式具有值，或重写代码使其不依赖于该值。

values_declaration_in_enum

#

不能在枚举中声明名为 'values' 的成员。

说明

#

当枚举声明定义名为 values 的成员时，分析器会生成此诊断信息，无论该成员是枚举值、实例成员还是静态成员。

任何此类成员都会与返回包含所有枚举常量的列表的隐式声明的静态 getter values 冲突。

示例

#

以下代码会生成此诊断信息，因为枚举 E 定义了一个名为 values 的实例成员：

dart
enum E {
  v;
  void values() {}
}

常规修复

#

更改冲突成员的名称：

dart
enum E {
  v;
  void getValues() {}
}

variable_length_array_not_last

#

可变长度 'Array' 只能作为 Struct 的最后一个字段出现。

说明

#

当可变长度内联 Array 不是 Struct 的最后一个成员时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 的类型有三个嵌套数组，但在 Array 注解中只给出了两个维度：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array.variable()
  external Array<Uint8> a0;

  @Uint8()
  external int a1;
}

常规修复

#

将可变长度内联 Array 移动到结构体的最后一个字段。

dart
import 'dart:ffi';

final class C extends Struct {
  @Uint8()
  external int a1;

  @Array.variable()
  external Array<Uint8> a0;
}

如果内联数组具有固定大小，则使用大小对其进行注释：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(10)
  external Array<Uint8> a0;

  @Uint8()
  external int a1;
}

variable_pattern_keyword_in_declaration_context

#

声明上下文中的变量模式不能指定 'var' 或 'final' 关键字。

说明

#

当在声明上下文中使用变量模式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为记录模式中的变量模式位于声明上下文中：

dart
void f((int, int) r) {
  var (var x, y) = r;
  print(x + y);
}

常规修复

#

删除变量模式中的 var 或 final 关键字：

dart
void f((int, int) r) {
  var (x, y) = r;
  print(x + y);
}

variable_type_mismatch

#

类型为 '{0}' 的值无法赋值给类型为 '{1}' 的 const 变量。

说明

#

当常量表达式的计算结果为 CastException 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 的值为 int ，它无法赋值给 y ，因为 int 不是 String ：

dart
const dynamic x = 0;
const String y = x;

常规修复

#

如果常量的声明正确，则更改正在赋值的值使其具有正确的类型：

dart
const dynamic x = 0;
const String y = '$x';

如果赋值的值正确，则更改声明使其具有正确的类型：

dart
const int x = 0;
const int y = x;

workspace_field_not_list

#

'workspace' 字段的值必须是相对文件路径的列表。

说明

#

当 workspace 键的值不是列表时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级 workspace 键的值是字符串，而预期的是列表：

yaml
name: example
workspace: notPaths

常规修复

#

更改 workspace 字段的值，使其成为列表：

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

workspace_value_not_string

#

Workspace 条目必须是目录路径（字符串）。

说明

#

当 workspace 列表包含不是字符串的值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 workspace 列表包含一个映射：

yaml
name: example
workspace:
    - image.gif: true

常规修复

#

更改 workspace 列表，使其只包含有效的 POSIX 样式目录路径：

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

workspace_value_not_subdirectory

#

Workspace 值必须是 '{0}' 的子目录的相对路径。

说明

#

当 workspace 列表包含的值不是包含 pubspec.yaml 文件的目录的子目录的相对路径时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 workspace 列表中的值不是包含 'pubspec.yaml' 文件的目录的子目录的相对路径：

yaml
name: example
workspace:
    - /home/my_package

常规修复

#

更改 workspace 列表，使其只包含子目录路径。

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

wrong_number_of_parameters_for_operator

#

运算符 '-' 应声明 0 个或 1 个参数，但找到 {0} 个。

运算符 '{0}' 应声明 {1} 个参数，但找到 {2} 个。

说明

#

当运算符的声明的参数数量错误时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为运算符 + 必须有一个与右操作数对应的参数：

dart
class C {
  int operator +(a, b) => 0;
}

常规修复

#

添加或删除参数以匹配所需的数量：

dart
class C {
  int operator +(a) => 0;
}

wrong_number_of_parameters_for_setter

#

setter 必须声明恰好一个必需的位置参数。

说明

#

当找到没有声明恰好一个必需位置参数的 setter 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 setter s 声明了两个必需的参数：

dart
class C {
  set s(int x, int y) {}
}

以下代码会生成此诊断信息，因为 setter s 声明了一个可选参数：

dart
class C {
  set s([int? x]) {}
}

常规修复

#

更改声明，使其恰好有一个必需的位置参数：

dart
class C {
  set s(int x) {}
}

wrong_number_of_type_arguments

#

类型 '{0}' 用 {1} 个类型参数声明，但给出 {2} 个类型参数。

说明

#

当使用具有类型参数的类型并提供类型参数，但类型参数的数量与类型参数的数量不同时，分析器会生成此诊断信息。

当调用构造函数，并且类型参数的数量与为类声明的类型参数的数量不匹配时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 有一个类型参数，但在将其用作类型注解时提供了两个类型参数：

dart
class C<E> {}

void f(C<int, int> x) {}

以下代码会生成此诊断信息，因为 C 声明了一个类型参数，但在创建实例时提供了两个类型参数：

dart
class C<E> {}

var c = C<int, int>() ;

常规修复

#

根据需要添加或删除类型参数，以匹配为类型定义的类型参数的数量：

dart
class C<E> {}

void f(C<int> x) {}

wrong_number_of_type_arguments_constructor

#

构造函数 '{0}.{1}' 没有类型参数。

说明

#

当在命名构造函数的名称后提供类型参数时，分析器会生成此诊断信息。构造函数不能声明类型参数，因此调用只能提供与类关联的类型参数，并且这些类型参数需要跟在类的名称后面而不是构造函数的名称后面。

示例

#

以下代码会生成此诊断信息，因为类型参数（ <String> ）位于构造函数的名称后面而不是类的名称后面：

dart
class C<T> {
  C.named();
}
C f() => C.named <String>() ;

常规修复

#

如果类型参数是类的类型参数，则将类型参数移动到类名称之后：

dart
class C<T> {
  C.named();
}
C f() => C<String>.named();

如果类型参数不是类的类型参数，则将其删除：

dart
class C<T> {
  C.named();
}
C f() => C.named();

yield_in_non_generator

#

yield 语句必须位于生成器函数中（用 'async*' 或 'sync*' 标记的函数）。

yield-each 语句必须位于生成器函数中（用 'async*' 或 'sync*' 标记的函数）。

说明

#

当 yield 或 yield* 语句出现在其主体未用 async* 或 sync* 修饰符标记的函数中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 yield 用于主体没有修饰符的函数中：

dart
Iterable<int> get digits {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

以下代码会生成此诊断信息，因为 yield* 用于主体具有 async 修饰符而不是 async* 修饰符的函数中：

dart
Stream<int> get digits async {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

常规修复

#

添加修饰符，或将现有修饰符更改为 async* 或 sync* ：

dart
Iterable<int> get digits sync* {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

yield_of_invalid_type

#

类型为 '{0}' 的 yield 值必须可赋值为 '{1}'。

由 'yield*' 表达式隐含的类型 '{0}' 必须可赋值为 '{1}'。

说明

#

当 yield 或 yield* 表达式产生的对象的类型与从生成器（用 sync* 或 async* 标记的函数或方法）返回的 Iterable 或 Stream 类型要返回的对象的类型不匹配时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 getter zero 声明为返回一个返回整数的 Iterable ，但 yield 从可迭代对象中返回一个字符串：

dart
Iterable<int> get zero sync* {
  yield '0';
}

常规修复

#

如果函数的返回类型正确，则修复 yield 关键字后的表达式以返回正确的类型：

dart
Iterable<int> get zero sync* {
  yield 0;
}

如果 yield 后的表达式正确，则更改函数的返回类型以允许它：

dart
Iterable<String> get zero sync* {
  yield '0';
}

always_declare_return_types

#

函数 '{0}' 应具有返回类型，但没有。

方法 '{0}' 应具有返回类型，但没有。

说明

#

当方法或函数没有显式返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 没有返回类型：

dart
f() {}

常规修复

#

添加显式返回类型：

dart
void f() {}

always_put_control_body_on_new_line

#

语句应在单独的行上。

说明

#

当控制流语句 (if 、 for 、 while 或 do) 控制的代码与控制流语句位于同一行时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 return 语句与控制是否执行 return 的 if 位于同一行：

dart
void f(bool b) {
  if (b) return;
}

常规修复

#

将受控语句放在单独的缩进行上：

dart
void f(bool b) {
  if (b)
    return;
}

always_put_required_named_parameters_first

#

必需的命名参数应位于可选命名参数之前。

说明

#

当必需的命名参数出现在可选命名参数之后时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为必需的参数 x 在可选参数 y 之后：

dart
void f({int? y, required int x}) {}

常规修复

#

重新排序参数，以便所有必需的命名参数都位于任何可选命名参数之前：

dart
void f({required int x, int? y}) {}

always_use_package_imports

#

对 'lib' 目录中的文件使用 'package:' 导入。

说明

#

当 lib 目录内的库中的 import 使用相对路径导入同一包的 lib 目录内的另一个库时，分析器会生成此诊断信息。

示例

#

假设名为 a.dart 的文件和下面的代码都在同一包的 lib 目录内，则以下代码会生成此诊断信息，因为它使用了相对 URI 来导入 a.dart ：

dart
import 'a.dart';

常规修复

#

使用包导入：

dart
import 'package:p/a.dart';

annotate_overrides

#

成员 '{0}' 覆盖了继承的成员，但没有用 '@override' 注释。

说明

#

当成员覆盖继承的成员，但没有用 @override 注释时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 B 中的方法 m 覆盖了类 A 中同名的方法，但没有标记为有意的覆盖：

dart
class A {
  void m() {}
}

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

常规修复

#

如果子类中的成员旨在覆盖超类中的成员，则添加 @override 注解：

dart
class A {
  void m() {}
}

class B extends A {
  @override
  void m() {}
}

如果子类中的成员不旨在覆盖超类中的成员，则重命名其中一个成员：

dart
class A {
  void m() {}
}

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

avoid_empty_else

#

在 'else' 子句中不允许使用空语句。

说明

#

当 else 后的语句为空语句（分号）时，分析器会生成此诊断信息。

更多信息，请参见 avoid_empty_else 的文档。

示例

#

以下代码会生成此诊断信息，因为 else 后的语句为空语句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  else ;
    print("2");
}

常规修复

#

如果 else 后的语句旨在仅在条件为 false 时执行，则删除空语句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  else
    print("2");
}

如果没有代码旨在仅在条件为 false 时执行，则删除整个 else 子句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  print("2");
}

avoid_function_literals_in_foreach_calls

#

不应将函数字面量传递给 'forEach'。

说明

#

当 Iterable.forEach 的参数是闭包时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 forEach 的调用的参数是闭包：

dart
void f(Iterable<String> s) {
  s. forEach((e) => print(e));
}

常规修复

#

如果闭包可以用分离来替换，则替换闭包：

dart
void f(Iterable<String> s) {
  s.forEach(print);
}

如果闭包不能用分离来替换，则使用 for 循环来迭代元素：

dart
void f(Iterable<String> s) {
  for (var e in s) {
    print(e);
  }
}

avoid_futureor_void

#

不要使用类型 'FutureOr'。

说明

#

当类型 FutureOr<void> 用作结果类型时（准确地说：它在非逆变的位置使用），分析器会生成此诊断信息。类型 FutureOr<void> 有问题，因为它似乎编码结果是 Future<void> ，或者结果应该被丢弃（当它是 void 时）。但是，没有安全的方法来检测我们是否有一个或另一个情况#### 说明

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是 const 构造函数：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

redirect_to_type_alias_expands_to_type_parameter

#

重定向构造函数不能重定向到扩展为类型参数的类型别名。

说明

#

当重定向工厂构造函数重定向到类型别名，并且类型别名扩展为类型别名的类型参数之一时，分析器会生成此诊断信息。这是不允许的，因为类型参数的值是类型而不是类。

示例

#

以下代码会生成此诊断信息，因为对 B<A> 的重定向是到值为 T 的类型别名，即使该值应为 A ：

dart
class A implements C {}

typedef B<T> = T;

abstract class C {
  factory C() = B<A>;
}

常规修复

#

使用定义为类的类名或类型别名，而不是定义为类型参数的类型别名：

dart
class A implements C {}

abstract class C {
  factory C() = A;
}

referenced_before_declaration

#

局部变量 '{0}' 在声明之前不能被引用。

说明

#

当在声明变量之前引用变量时，分析器会生成此诊断信息。在 Dart 中，变量在其声明的块中的任何地方都是可见的，但只能在其声明之后才能被引用。

分析器还会生成上下文消息，指示声明的位置。

示例

#

以下代码会生成此诊断信息，因为 i 在声明之前被使用：

dart
void f() {
  print(i);
  int i = 5;
}

常规修复

#

如果您打算引用局部变量，请将声明移动到第一次引用之前：

dart
void f() {
  int i = 5;
  print(i);
}

如果您打算引用外部作用域中的名称，例如参数、实例字段或顶级变量，则重命名局部声明，使其不隐藏外部变量。

dart
void f(int i) {
  print(i);
  int x = 5;
  print(x);
}

refutable_pattern_in_irrefutable_context

#

可反驳的模式不能在不可反驳的上下文中使用。

说明

#

当在只允许 不可反驳的模式 的上下文中使用 可反驳的模式 时，分析器会生成此诊断信息。

不允许的可反驳模式是：

  • 逻辑或
  • 关系
  • 空检查
  • 常量

检查的上下文是：

  • 基于模式的变量声明
  • 基于模式的 for 循环
  • 左侧有模式的赋值

示例

#

以下代码会生成此诊断信息，因为空检查模式（它是一个可反驳的模式）位于基于模式的变量声明中，基于模式的变量声明不允许可反驳模式：

dart
void f(int? x) {
  var (_?) = x;
}

常规修复

#

重写代码，使其不在不可反驳的上下文中使用可反驳的模式。

relational_pattern_operand_type_not_assignable

#

常量表达式类型 '{0}' 无法赋值给 '{2}' 运算符的参数类型 '{1}'。

说明

#

当关系模式的操作数的类型无法赋值给将调用的运算符的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式（ 0 ）中的操作数是 int ，但 C 中定义的 > 运算符期望一个类型为 C 的对象：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > 0:
      print('positive');
  }
}

常规修复

#

如果 switch 使用正确的值，则更改 case 以将值与正确的对象类型进行比较：

dart
class C {
  const C();

  bool operator >(C other) => true;
}

void f(C c) {
  switch (c) {
    case > const C():
      print('positive');
  }
}

如果 switch 使用错误的值，则更改用于计算正在匹配的值的表达式：

dart
class C {
  const C();

  bool operator >(C other) => true;

  int get toInt => 0;
}

void f(C c) {
  switch (c.toInt) {
    case > 0:
      print('positive');
  }
}

relational_pattern_operator_return_type_not_assignable_to_bool

#

关系模式中使用的运算符的返回类型必须可赋值为 'bool'。

说明

#

当关系模式引用一个不产生类型为 bool 的值的运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为关系模式 > c2 中使用的运算符 > 返回类型为 int 的值而不是 bool ：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

常规修复

#

如果有其他应使用的运算符，则更改运算符：

dart
class C {
  const C();

  int operator >(C c) => 3;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case < c2) {}
}

如果运算符应返回 bool ，则更新运算符的声明：

dart
class C {
  const C();

  bool operator >(C c) => true;

  bool operator <(C c) => false;
}

const C c2 = C();

void f(C c1) {
  if (c1 case > c2) {}
}

rest_element_in_map_pattern

#

映射模式不能包含 rest 模式。

说明

#

当映射模式包含 rest 模式时，分析器会生成此诊断信息。映射模式匹配键多于模式中显式给出的键的映射（只要给定的键匹配），因此 rest 模式是不必要的。

示例

#

以下代码会生成此诊断信息，因为映射模式包含 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _, ...}) {}
}

常规修复

#

删除 rest 模式：

dart
void f(Map<int, String> x) {
  if (x case {0: _}) {}
}

rethrow_outside_catch

#

rethrow 必须位于 catch 子句中。

说明

#

当 rethrow 语句位于 catch 子句之外时，分析器会生成此诊断信息。 rethrow 语句用于再次抛出捕获的异常，但在 catch 子句之外没有捕获的异常。

示例

#

以下代码会生成此诊断信息，因为 rethrow 语句位于 catch 子句之外：

dart
void f() {
  rethrow;
}

常规修复

#

如果您尝试重新抛出异常，则将 rethrow 语句包装在 catch 子句中：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    rethrow;
  }
}

如果您尝试抛出一个新的异常，则将 rethrow 语句替换为 throw 表达式：

dart
void f() {
  throw UnsupportedError('Not yet implemented');
}

return_in_generative_constructor

#

构造函数不能返回值。

说明

#

当生成式构造函数包含一个指定要返回的值的 return 语句时，分析器会生成此诊断信息。生成式构造函数始终返回已创建的对象，因此不能返回不同的对象。

示例

#

以下代码会生成此诊断信息，因为 return 语句有一个表达式：

dart
class C {
  C() {
    return this;
  }
}

常规修复

#

如果构造函数应创建一个新的实例，则删除 return 语句或表达式：

dart
class C {
  C();
}

如果构造函数不应创建新的实例，则将其转换为工厂构造函数：

dart
class C {
  factory C() {
    return _instance;
  }

  static C _instance = C._();

  C._();
}

return_in_generator

#

不能从使用 'async*' 或 'sync*' 修饰符的生成器函数返回值。

说明

#

当生成器函数（其主体用 async* 或 sync* 标记）使用 return 语句返回值或由于使用 => 而隐式返回值时，分析器会生成此诊断信息。在任何这些情况下，它们都应使用 yield 代替 return 。

示例

#

以下代码会生成此诊断信息，因为方法 f 是生成器，并且正在使用 return 返回值：

dart
Iterable<int> f() sync* {
  return 3;
}

以下代码会生成此诊断信息，因为函数 f 是生成器，并且正在隐式返回值：

dart
Stream<int> f() async* => 3;

常规修复

#

如果函数对函数体使用 => ，则将其转换为块函数体，并使用 yield 返回值：

dart
Stream<int> f() async* {
  yield 3;
}

如果该方法旨在作为生成器，则使用 yield 返回值：

dart
Iterable<int> f() sync* {
  yield 3;
}

如果该方法不旨在作为生成器，则从主体中删除修饰符（或者如果您要返回 future，则使用 async ）：

dart
int f() {
  return 3;
}

return_of_do_not_store

#

' {0}' 用 'doNotStore' 注释，除非 '{1}' 也被注释，否则不应返回。

说明

#

当用 doNotStore 注解注释的值从没有相同注解的方法、getter 或函数中返回时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为不应该存储调用 f 的结果，但函数 g 没有被注释以保留该语义：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => f();

常规修复

#

如果不应该存储的值是正确的返回值，则使用 doNotStore 注解标记该函数：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

@doNotStore
int g() => f();

否则，从函数中返回不同的值：

dart
import 'package:meta/meta.dart';

@doNotStore
int f() => 0;

int g() => 0;

return_of_invalid_type

#

类型为 '{0}' 的值无法从构造函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从函数 '{2}' 返回，因为它返回类型为 '{1}'。

类型为 '{0}' 的值无法从方法 '{2}' 返回，因为它返回类型为 '{1}'。

说明

#

当方法或函数返回的值的类型无法赋值给声明的返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 的返回类型为 String ，但它返回的是 int ：

dart
String f() => 3;

常规修复

#

如果返回类型正确，则用正确类型的返回值替换正在返回的值，可能通过转换现有值：

dart
String f() => 3.toString();

redirect_to_non_const_constructor

#

常量重定向构造函数不能重定向到非常量构造函数。

说明

#

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是 const 构造函数：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

如果生成式构造函数是未命名的构造函数，并且没有参数传递给它，则可以删除超类调用。

non_generative_implicit_constructor

#

超类 '{0}' 的未命名构造函数（由 '{1}' 的默认构造函数调用）必须是生成式构造函数，但找到了工厂构造函数。

说明

#

当类具有隐式生成式构造函数，而超类具有显式未命名的工厂构造函数时，分析器会生成此诊断信息。子类中的隐式构造函数隐式调用超类中的未命名构造函数，但生成式构造函数只能调用另一个生成式构造函数，而不能调用工厂构造函数。

示例

#

以下代码会生成此诊断信息，因为 B 中的隐式构造函数调用 A 中的未命名构造函数，但 A 中的构造函数是工厂构造函数，而需要生成式构造函数：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B extends A {}

常规修复

#

如果超类中的未命名构造函数可以是生成式构造函数，则将其更改为生成式构造函数：

dart
class A {
  A();
  A.named();
}

class B extends A { }

如果未命名构造函数不能是生成式构造函数，并且超类中还有其他生成式构造函数，则显式调用其中一个：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B extends A {
  B() : super.named();
}

如果没有可以使用的生成式构造函数，并且不能添加任何生成式构造函数，则实现超类而不是扩展它：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B implements A {}

non_native_function_type_argument_to_pointer

#

无法调用 'asFunction'，因为指针的函数签名 '{0}' 不是有效的 C 函数签名。

说明

#

当在指向本机函数的指针上调用 asFunction 方法，但本机函数的签名不是有效的 C 函数签名时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为与指针 p 关联的函数签名（ FNative ）不是有效的 C 函数签名：

dart
import 'dart:ffi';

typedef FNative = int Function(int);
typedef F = int Function(int);

class C {
  void f(Pointer<NativeFunction<FNative>> p) {
    p.asFunction<F>();
  }
}

常规修复

#

使 NativeFunction 签名成为有效的 C 签名：

dart
import 'dart:ffi';

typedef FNative = Int8 Function(Int8);
typedef F = int Function(int);

class C {
  void f(Pointer<NativeFunction<FNative>> p) {
    p.asFunction<F>();
  }
}

non_positive_array_dimension

#

数组维度必须是正数。

说明

#

当 Array 注解中给定的维度小于或等于零 (0) 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为提供了 -1 的数组维度：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array(-8)
  external Array<Uint8> a0;
}

常规修复

#

将维度更改为正整数：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

如果这是一个可变长度的内联数组，则将注解更改为 Array.variable() ：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array.variable()
  external Array<Uint8> a0;
}

non_sized_type_argument

#

类型 '{1}' 不是 '{0}' 的有效类型参数。类型参数必须是本机整数、'Float'、'Double'、'Pointer' 或 'Struct'、'Union' 或 'AbiSpecificInteger' 的子类型。

说明

#

当 Array 类的类型参数不是有效类型之一时，分析器会生成此诊断信息：本机整数、 Float 、 Double 、 Pointer 或 Struct 、 Union 或 AbiSpecificInteger 的子类型。

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

示例

#

以下代码会生成此诊断信息，因为 Array 的类型参数是 Void ，而 Void 不是有效类型之一：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Void> a0;
}

常规修复

#

将类型参数更改为有效类型之一：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

non_sync_factory

#

工厂体不能使用 'async'、'async*' 或 'sync*'。

说明

#

当工厂构造函数的体用 async 、 async* 或 sync* 标记时，分析器会生成此诊断信息。所有构造函数（包括工厂构造函数）都需要返回声明它们的类的实例，而不是 Future 、 Stream 或 Iterator 。

示例

#

以下代码会生成此诊断信息，因为工厂构造函数的体用 async 标记：

dart
class C {
  factory C() async {
    return C._();
  }
  C._();
}

常规修复

#

如果必须将成员声明为工厂构造函数，则删除主体之前的关键字：

dart
class C {
  factory C() {
    return C._();
  }
  C._();
}

如果成员必须返回除封闭类的实例以外的其他内容，则将成员设为静态方法：

dart
class C {
  static Future<C> m() async {
    return C._();
  }
  C._();
}

non_type_as_type_argument

#

名称 '{0}' 不是类型，因此不能用作类型参数。

说明

#

当不是类型的标识符用作类型参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 是变量，而不是类型：

dart
var x = 0;
List<x> xList = [];

常规修复

#

将类型参数更改为类型：

dart
var x = 0;
List<int> xList = [];

non_type_in_catch_clause

#

名称 '{0}' 不是类型，不能用于 on-catch 子句中。

说明

#

当 catch 子句中的 on 后的标识符被定义为非类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是函数，而不是类型：

dart
void f() {
  try {
    // ...
  } on f {
    // ...
  }
}

常规修复

#

将名称更改为应捕获的对象类型：

dart
void f() {
  try {
    // ...
  } on FormatException {
    // ...
  }
}

non_void_return_for_operator

#

运算符 []= 的返回类型必须是 'void'。

说明

#

当 []= 运算符的声明的返回类型不是 void 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 []= 运算符的声明的返回类型为 int ：

dart
class C {
  int operator []=(int index, int value) => 0;
}

常规修复

#

将返回类型更改为 void ：

dart
class C {
  void operator []=(int index, int value) => 0;
}

non_void_return_for_setter

#

setter 的返回类型必须是 'void' 或不存在。

说明

#

当 setter 的定义的返回类型不是 void 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 setter p 的返回类型为 int ：

dart
class C {
  int set p(int i) => 0;
}

常规修复

#

将返回类型更改为 void 或省略返回类型：

dart
class C {
  set p(int i) => 0;
}

not_assigned_potentially_non_nullable_local_variable

#

非空局部变量 '{0}' 必须在使用之前赋值。

说明

#

当引用局部变量并且具有以下所有特征时，分析器会生成此诊断信息：

  • 具有 潜在的非空类型 。
  • 没有初始化器。
  • 未标记为 late 。
  • 分析器无法根据 明确赋值 的规范证明在引用之前将为局部变量赋值。

示例

#

以下代码会生成此诊断信息，因为 x 不能具有 null 值，但在为其赋值之前就被引用了：

dart
String f() {
  int x;
  return x.toString();
}

以下代码会生成此诊断信息，因为对 x 的赋值可能不会执行，因此它可能具有 null 值：

dart
int g(bool b) {
  int x;
  if (b) {
    x = 1;
  }
  return x * 2;
}

以下代码会生成此诊断信息，因为分析器无法根据明确赋值分析证明 x 不会在未为其赋值的情况下被引用：

dart
int h(bool b) {
  int x;
  if (b) {
    x = 1;
  }
  if (b) {
    return x * 2;
  }
  return 0;
}

常规修复

#

如果 null 是有效值，则使变量可为空：

dart
String f() {
  int? x;
  return x!.toString();
}

如果 null 不是有效值，并且有合理的默认值，则添加初始化器：

dart
int g(bool b) {
  int x = 2;
  if (b) {
    x = 1;
  }
  return x * 2;
}

否则，确保在访问该值之前，在每条可能的代码路径上都为其赋值：

dart
int g(bool b) {
  int x;
  if (b) {
    x = 1;
  } else {
    x = 2;
  }
  return x * 2;
}

您也可以将变量标记为 late ，这将删除诊断信息，但如果在访问变量之前未为其赋值，则会导致在运行时抛出异常。只有在您确定变量将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
int h(bool b) {
  late int x;
  if (b) {
    x = 1;
  }
  if (b) {
    return x * 2;
  }
  return 0;
}

not_a_type

#

{0} 不是类型。

说明

#

当名称用作类型但被声明为非类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是函数：

dart
f() {}
g(f v) {}

常规修复

#

将名称替换为类型的名称。

not_binary_operator

#

' {0}' 不是二元运算符。

说明

#

当只能用作一元运算符的运算符用作二元运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为运算符 ~ 只能用作一元运算符：

dart
var a = 5 ~ 3;

常规修复

#

将运算符替换为正确的二元运算符：

dart
var a = 5 - 3;

not_enough_positional_arguments

#

' {0}' 预期有 1 个位置参数，但找到 0 个。

预期有 1 个位置参数，但找到 0 个。

' {2}' 预期有 {0} 个位置参数，但找到 {1} 个。

{0} 个位置参数预期，但找到 {1} 个。

说明

#

当方法或函数调用的位置参数少于必需位置参数的数量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 声明了两个必需参数，但只提供了一个参数：

dart
void f(int a, int b) {}
void g() {
  f(0);
}

常规修复

#

添加与其余参数对应的参数：

dart
void f(int a, int b) {}
void g() {
  f(0, 1);
}

not_initialized_non_nullable_instance_field

#

非空实例字段 '{0}' 必须初始化。

说明

#

当声明字段并具有以下所有特征时，分析器会生成此诊断信息：

示例

#

以下代码会生成此诊断信息，因为 x 在不允许为 null 时隐式初始化为 null ：

dart
class C {
  int x;
}

类似地，以下代码会生成此诊断信息，因为 x 在不允许为 null 时被其中一个构造函数隐式初始化为 null ，即使它由其他构造函数初始化：

dart
class C {
  int x;

  C(this.x);

  C.n();
}

常规修复

#

如果所有实例的字段都有合理的默认值，则添加初始化表达式：

dart
class C {
  int x = 0;
}

如果在创建实例时应提供字段的值，则添加一个设置字段值的构造函数或更新现有构造函数：

dart
class C {
  int x;

  C(this.x);
}

您还可以将字段标记为 late ，这将删除诊断信息，但如果在访问字段之前未为其赋值，则会导致在运行时抛出异常。只有在您确定字段在引用之前将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
class C {
  late int x;
}

not_initialized_non_nullable_variable

#

非空变量 '{0}' 必须初始化。

说明

#

当静态字段或顶级变量具有非空类型并且没有初始化器时，分析器会生成此诊断信息。通常，没有初始化器的字段和变量被初始化为 null ，但字段或变量的类型不允许将其设置为 null ，因此必须提供显式初始化器。

示例

#

以下代码会生成此诊断信息，因为字段 f 不能初始化为 null ：

dart
class C {
  static int f;
}

类似地，以下代码会生成此诊断信息，因为顶级变量 v 不能初始化为 null ：

dart
int v;

常规修复

#

如果字段或变量不能初始化为 null ，则添加一个将其设置为非空值的初始化器：

dart
class C {
  static int f = 0;
}

如果字段或变量应初始化为 null ，则将类型更改为可为空：

dart
int? v;

如果字段或变量不能在声明中初始化，但在引用之前将始终初始化，则将其标记为 late ：

dart
class C {
  static late int f;
}

not_iterable_spread

#

列表或集合字面量中的展开元素必须实现 'Iterable'。

说明

#

当出现在列表字面量或集合字面量中的展开元素的表达式的静态类型没有实现类型 Iterable 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m};

常规修复

#

最常见的修复方法是用产生可迭代对象的表达式替换该表达式：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m.keys};

not_map_spread

#

映射字面量中的展开元素必须实现 'Map'。

说明

#

当出现在映射字面量中的展开元素的表达式的静态类型没有实现类型 Map 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 l 不是 Map ：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l};

常规修复

#

最常见的修复方法是用产生映射的表达式替换该表达式：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l.asMap()};

no_annotation_constructor_arguments

#

注解创建必须有参数。

说明

#

当注解由单个标识符组成，但该标识符是类的名称而不是变量的名称时，分析器会生成此诊断信息。要创建类的实例，标识符后必须跟一个参数列表。

示例

#

以下代码会生成此诊断信息，因为 C 是一个类，并且如果没有从类中调用 const 构造函数，则不能将类用作注解：

dart
class C {
  const C();
}

@C
var x;

常规修复

#

添加缺少的参数列表：

dart
class C {
  const C();
}

@C()
var x;

no_combined_super_signature

#

无法从被覆盖的方法推断 '{0}' 中缺少的类型：{1}。

说明

#

当存在需要推断一个或多个类型的函数声明，并且由于没有被覆盖的方法的函数类型是所有其他被覆盖方法的超类型（如 覆盖推断 所指定）时，无法推断这些类型，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 C 中声明的方法 m 缺少返回类型和参数 a 的类型，并且无法为其推断任何缺少的类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  m(a) ;
}

在此示例中，无法执行覆盖推断，因为被覆盖的方法在以下方面不兼容：

  • 参数类型（ String 和 int ）都不是对方的超类型。
  • 返回类型都不是对方的子类型。

常规修复

#

如果可能，向子类中与所有被覆盖方法的类型一致的方法添加类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  C m(Object a);
}

no_generative_constructors_in_superclass

#

_类 '{0}' 不能扩展 '{1}'，因为 '{1}' 只有工厂构造函数（没有生成式构造函数），而#### 说明

当类型检查（使用 is 或 is! ）的值在编译时已知时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为测试 a is Object? 始终为 true ：

dart
bool f<T>(T a) => a is Object?;

常规修复

#

如果类型检查没有检查您想要检查的内容，则更改测试：

dart
bool f<T>(T a) => a is Object;

如果类型检查确实检查了您想要检查的内容，则将类型检查替换为其已知值或将其完全删除：

dart
bool f<T>(T a) => true;

unqualified_reference_to_non_local_static_member

#

超类型中的静态 {1} '{0}' 必须由定义类型的名称限定。

说明

#

当一个类中的代码引用超类中的静态成员，而没有在成员名称前加上超类的名称时，分析器会生成此诊断信息。静态成员只能在其声明的类中无前缀地引用。

示例

#

以下代码会生成此诊断信息，因为静态字段 x 在 getter g 中被引用，而没有在它前面加上定义类的名称：

dart
class A {
  static int x = 3;
}

class B extends A {
  int get g => x;
}

常规修复

#

在静态成员的名称前加上声明类的名称：

dart
class A {
  static int x = 3;
}

class B extends A {
  int get g => A.x;
}

unqualified_reference_to_static_member_of_extended_type

#

扩展类型或其超类之一中的静态成员必须由定义类型的名称限定。

说明

#

当找到未定义的名称，并且该名称与扩展类型或其超类之一的静态成员相同时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 是扩展类型 C 的静态成员：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    m() ;
  }
}

常规修复

#

如果您尝试引用在扩展之外声明的静态成员，则在对成员的引用之前添加类或扩展的名称：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    C.m();
  }
}

如果您正在引用尚未声明的成员，请添加声明：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    m();
  }

  void m() {}
}

unreachable_switch_case

#

此 case 被前面的 cases 覆盖。

说明

#

当 switch 语句中的 case 子句由于所有可匹配的值都被前面 case 子句匹配而无法匹配任何内容时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值 1 在前面的 case 中已匹配：

dart
void f(int x) {
  switch (x) {
    case 1:
      print('one');
    case 1:
      print('two');
  }
}

常规修复

#

更改一个或两个冲突的 cases 以匹配不同的值：

dart
void f(int x) {
  switch (x) {
    case 1:
      print('one');
    case 2:
      print('two');
  }
}

unreachable_switch_default

#

此 default 子句被前面的 cases 覆盖。

说明

#

当 switch 语句中的 default 子句由于所有可匹配的值都被前面 case 子句匹配而无法匹配任何内容时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值 E.e1 和 E.e2 在前面的 cases 中已匹配：

dart
enum E { e1, e2 }

void f(E x) {
  switch (x) {
    case E.e1:
      print('one');
    case E.e2:
      print('two');
    default:
      print('other');
  }
}

常规修复

#

删除不必要的 default 子句：

dart
enum E { e1, e2 }
void f(E x) {
  switch (x) {
    case E.e1:
      print('one');
    case E.e2:
      print('two');
  }
}

unused_catch_clause

#

异常变量 '{0}' 未使用，因此可以删除 'catch' 子句。

说明

#

当找到 catch 子句，并且 catch 块中既未使用异常参数也未使用可选堆栈跟踪参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 e 未被引用：

dart
void f() {
  try {
    int.parse(';');
  } on FormatException catch (e) {
    // ignored
  }
}

常规修复

#

删除未使用的 catch 子句：

dart
void f() {
  try {
    int.parse(';');
  } on FormatException {
    // ignored
  }
}

unused_catch_stack

#

堆栈跟踪变量 '{0}' 未使用，可以删除。

说明

#

当 catch 子句中的堆栈跟踪参数未在 catch 块的主体中引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 stackTrace 未被引用：

dart
void f() {
  try {
    // ...
  } catch (exception, stackTrace) {
    // ...
  }
}

常规修复

#

如果您需要引用堆栈跟踪参数，则添加对它的引用。否则，将其删除：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    // ...
  }
}

unused_element

#

声明 '{0}' 未被引用。

说明

#

当私有声明在其包含声明的库中未被引用时，分析器会生成此诊断信息。将分析以下类型的声明：

  • 私有的顶级声明及其所有成员
  • 公共声明的私有成员

并非对元素的所有引用都会将其标记为“已使用”：

  • 将值赋值给顶级变量（使用标准 = 赋值或空感知 ??= 赋值）不计为使用它。
  • 在文档注释引用中引用元素不计为使用它。
  • 在 is 表达式的右侧引用类、mixin 或枚举不计为使用它。

示例

#

假设库中的任何代码都没有引用 _C ，则以下代码会生成此诊断信息：

dart
class _C {}

常规修复

#

如果不需要声明，则将其删除。

如果打算使用声明，则添加使用它的代码。

unused_element_parameter

#

从不为可选参数 '{0}' 提供值。

说明

#

当从不为私有声明中声明的可选参数传递值时，分析器会生成此诊断信息。

示例

#

假设库中的任何代码都没有在任何 _m 的调用中为 y 传递值，则以下代码会生成此诊断信息：

dart
class C {
  void _m(int x, [int? y]) {}

  void n() => _m(0);
}

常规修复

#

如果不需要声明，则将其删除：

dart
class C {
  void _m(int x) {}

  void n() => _m(0);
}

如果打算使用声明，则添加使用它的代码。

unused_field

#

字段 '{0}' 的值未使用。

说明

#

当声明私有字段但从未读取它时，即使在一个或多个地方写入它，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 _originalValue 在库中任何地方都没有被读取：

dart
class C {
  final String _originalValue;
  final String _currentValue;

  C(this._originalValue) : _currentValue = _originalValue;

  String get value => _currentValue;
}

它可能看起来像字段 _originalValue 在初始化器 (_currentValue = _originalValue) 中被读取，但这实际上是在引用同名参数，而不是引用该字段。

常规修复

#

如果不需要该字段，则将其删除。

如果打算使用该字段，则添加缺少的代码。

unused_import

#

未使用的导入：'{0}'。

说明

#

当导入不需要，因为导入的名称均未在导入库中引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:async 中定义的任何内容在库中都没有被引用：

dart
import 'dart:async';

void main() {}

常规修复

#

如果不需要导入，则将其删除。

如果打算使用某些导入的名称，则添加缺少的代码。

unused_label

#

标签 '{0}' 未使用。

说明

#

当找到未使用的标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标签 loop 在方法中任何地方都没有被引用：

dart
void f(int limit) {
  loop: for (int i = 0; i < limit; i++) {
    print(i);
  }
}

常规修复

#

如果不需要标签，则将其删除：

dart
void f(int limit) {
  for (int i = 0; i < limit; i++) {
    print(i);
  }
}

如果需要标签，则使用它：

dart
void f(int limit) {
  loop: for (int i = 0; i < limit; i++) {
    print(i);
    if (i != 0) {
      break loop;
    }
  }
}

unused_local_variable

#

局部变量 '{0}' 的值未使用。

说明

#

当声明局部变量但从未读取它时，即使在一个或多个地方写入它，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为从未读取 count 的值：

dart
void main() {
  int count = 0;
}

常规修复

#

如果不需要该变量，则将其删除。

如果打算使用该变量，则添加缺少的代码。

unused_result

#

' {0}' 应使用。{1}。

' {0}' 的值应使用。

说明

#

当调用用 useResult 注解注释的函数，并且未使用该函数返回的值时，分析器会生成此诊断信息。如果调用的值，如果该值传递给另一个函数，或者如果该值被赋值给变量或字段，则该值被认为是使用的。

示例

#

以下代码会生成此诊断信息，因为 c.a() 的调用未使用，即使方法 a 用 useResult 注解注释：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  c. a() ;
}

常规修复

#

如果您打算调用带注解的函数，则使用返回的值：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  print(c.a());
}

如果您打算调用不同的函数，则更正正在调用的函数的名称：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  c.b();
}

unused_shown_name

#

显示了名称 {0}，但未使用。

说明

#

当显示组合器包含未在库中使用的名称时，分析器会生成此诊断信息。因为它没有被引用，所以可以删除该名称。

示例

#

以下代码会生成此诊断信息，因为函数 max 未使用：

dart
import 'dart:math' show min, max;

var x = min(0, 1);

常规修复

#

使用该名称或将其删除：

dart
import 'dart:math' show min;

var x = min(0, 1);

uri_does_not_exist

#

URI 的目标不存在：'{0}'。

说明

#

当找到导入、导出或部分指令，并且 URI 引用不存在的文件时，分析器会生成此诊断信息。

示例

#

如果文件 lib.dart 不存在，则以下代码会生成此诊断信息：

dart
import 'lib.dart';

常规修复

#

如果 URI 键入错误或无效，则更正 URI。

如果 URI 正确，则创建该文件。

uri_does_not_exist_in_doc_import

#

URI 的目标不存在：'{0}'。

说明

#

当找到文档导入，并且 URI 引用不存在的文件时，分析器会生成此诊断信息。

示例

#

如果文件 lib.dart 不存在，则以下代码会生成此诊断信息：

dart
/// @docImport 'lib.dart';
library;

常规修复

#

如果 URI 键入错误或无效，则更正 URI。

如果 URI 正确，则创建该文件。

uri_has_not_been_generated

#

URI 的目标尚未生成：'{0}'。

说明

#

当找到导入、导出或部分指令，并且 URI 引用不存在的文件，并且文件名以代码生成器通常生成的模式结尾（例如以下模式之一）时，分析器会生成此诊断信息：

  • .g.dart
  • .pb.dart
  • .pbenum.dart
  • .pbserver.dart
  • .pbjson.dart
  • .template.dart

示例

#

如果文件 lib.g.dart 不存在，则以下代码会生成此诊断信息：

dart
import 'lib.g.dart';

常规修复

#

如果该文件是生成的文件，则运行生成该文件的生成器。

如果该文件不是生成的文件，则检查 URI 的拼写或创建该文件。

uri_with_interpolation

#

URI 不能使用字符串插值。

说明

#

当 import 、 export 或 part 指令中的字符串字面量包含插值时，分析器会生成此诊断信息。指令中 URI 的解析必须在声明编译之前发生，因此在确定 URI 的值时不能计算表达式。

示例

#

以下代码会生成此诊断信息，因为 import 指令中的字符串包含插值：

dart
import 'dart:$m';

const m = 'math';

常规修复

#

从 URI 中删除插值：

dart
import 'dart:math';

var zero = min(0, 0);

use_of_native_extension

#

Dart 本机扩展已弃用，在 Dart 2.15 中不可用。

说明

#

当使用 dart-ext 方案导入库时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为本机库 x 使用 dart-ext 方案导入：

dart
import 'dart-ext:x';

常规修复

#

重写代码以使用 dart:ffi 作为调用本机库内容的一种方式。

use_of_void_result

#

此表达式的类型为 'void'，因此其值不能使用。

说明

#

当分析器找到类型为 void 的表达式，并且该表达式在需要值的地方使用时（例如，在成员访问之前或赋值的右侧），分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 没有生成可以调用 toString 的对象：

dart
void f() {}

void g() {
  f().toString();
}

常规修复

#

重写代码使表达式具有值，或重写代码使其不依赖于该值。

values_declaration_in_enum

#

不能在枚举中声明名为 'values' 的成员。

说明

#

当枚举声明定义名为 values 的成员时，分析器会生成此诊断信息，无论该成员是枚举值、实例成员还是静态成员。

任何此类成员都会与返回包含所有枚举常量的列表的隐式声明的静态 getter values 冲突。

示例

#

以下代码会生成此诊断信息，因为枚举 E 定义了一个名为 values 的实例成员：

dart
enum E {
  v;
  void values() {}
}

常规修复

#

更改冲突成员的名称：

dart
enum E {
  v;
  void getValues() {}
}

variable_length_array_not_last

#

可变长度 'Array' 只能作为 Struct 的最后一个字段出现。

说明

#

当可变长度内联 Array 不是 Struct 的最后一个成员时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 的类型有三个嵌套数组，但在 Array 注解中只给出了两个维度：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array.variable()
  external Array<Uint8> a0;

  @Uint8()
  external int a1;
}

常规修复

#

将可变长度内联 Array 移动到结构体的最后一个字段。

dart
import 'dart:ffi';

final class C extends Struct {
  @Uint8()
  external int a1;

  @Array.variable()
  external Array<Uint8> a0;
}

如果内联数组具有固定大小，则使用大小对其进行注释：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(10)
  external Array<Uint8> a0;

  @Uint8()
  external int a1;
}

variable_pattern_keyword_in_declaration_context

#

声明上下文中的变量模式不能指定 'var' 或 'final' 关键字。

说明

#

当在声明上下文中使用变量模式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为记录模式中的变量模式位于声明上下文中：

dart
void f((int, int) r) {
  var (var x, y) = r;
  print(x + y);
}

常规修复

#

删除变量模式中的 var 或 final 关键字：

dart
void f((int, int) r) {
  var (x, y) = r;
  print(x + y);
}

variable_type_mismatch

#

类型为 '{0}' 的值无法赋值给类型为 '{1}' 的 const 变量。

说明

#

当常量表达式的计算结果为 CastException 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 的值为 int ，它无法赋值给 y ，因为 int 不是 String ：

dart
const dynamic x = 0;
const String y = x;

常规修复

#

如果常量的声明正确，则更改正在赋值的值使其具有正确的类型：

dart
const dynamic x = 0;
const String y = '$x';

如果赋值的值正确，则更改声明使其具有正确的类型：

dart
const int x = 0;
const int y = x;

workspace_field_not_list

#

'workspace' 字段的值必须是相对文件路径的列表。

说明

#

当 workspace 键的值不是列表时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级 workspace 键的值是字符串，而预期的是列表：

yaml
name: example
workspace: notPaths

常规修复

#

更改 workspace 字段的值，使其成为列表：

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

workspace_value_not_string

#

Workspace 条目必须是目录路径（字符串）。

说明

#

当 workspace 列表包含不是字符串的值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 workspace 列表包含一个映射：

yaml
name: example
workspace:
    - image.gif: true

常规修复

#

更改 workspace 列表，使其只包含有效的 POSIX 样式目录路径：

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

workspace_value_not_subdirectory

#

Workspace 值必须是 '{0}' 的子目录的相对路径。

说明

#

当 workspace 列表包含的值不是包含 pubspec.yaml 文件的目录的子目录的相对路径时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 workspace 列表中的值不是包含 'pubspec.yaml' 文件的目录的子目录的相对路径：

yaml
name: example
workspace:
    - /home/my_package

常规修复

#

更改 workspace 列表，使其只包含子目录路径。

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

wrong_number_of_parameters_for_operator

#

运算符 '-' 应声明 0 个或 1 个参数，但找到 {0} 个。

运算符 '{0}' 应声明 {1} 个参数，但找到 {2} 个。

说明

#

当运算符的声明的参数数量错误时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为运算符 + 必须有一个与右操作数对应的参数：

dart
class C {
  int operator +(a, b) => 0;
}

常规修复

#

添加或删除参数以匹配所需的数量：

dart
class C {
  int operator +(a) => 0;
}

wrong_number_of_parameters_for_setter

#

setter 必须声明恰好一个必需的位置参数。

说明

#

当找到没有声明恰好一个必需位置参数的 setter 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 setter s 声明了两个必需的参数：

dart
class C {
  set s(int x, int y) {}
}

以下代码会生成此诊断信息，因为 setter s 声明了一个可选参数：

dart
class C {
  set s([int? x]) {}
}

常规修复

#

更改声明，使其恰好有一个必需的位置参数：

dart
class C {
  set s(int x) {}
}

wrong_number_of_type_arguments

#

类型 '{0}' 用 {1} 个类型参数声明，但给出 {2} 个类型参数。

说明

#

当使用具有类型参数的类型并提供类型参数，但类型参数的数量与类型参数的数量不同时，分析器会生成此诊断信息。

当调用构造函数，并且类型参数的数量与为类声明的类型参数的数量不匹配时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 有一个类型参数，但在将其用作类型注解时提供了两个类型参数：

dart
class C<E> {}

void f(C<int, int> x) {}

以下代码会生成此诊断信息，因为 C 声明了一个类型参数，但在创建实例时提供了两个类型参数：

dart
class C<E> {}

var c = C<int, int>() ;

常规修复

#

根据需要添加或删除类型参数，以匹配为类型定义的类型参数的数量：

dart
class C<E> {}

void f(C<int> x) {}

wrong_number_of_type_arguments_constructor

#

构造函数 '{0}.{1}' 没有类型参数。

说明

#

当在命名构造函数的名称后提供类型参数时，分析器会生成此诊断信息。构造函数不能声明类型参数，因此调用只能提供与类关联的类型参数，并且这些类型参数需要跟在类的名称后面而不是构造函数的名称后面。

示例

#

以下代码会生成此诊断信息，因为类型参数（ <String> ）位于构造函数的名称后面而不是类的名称后面：

dart
class C<T> {
  C.named();
}
C f() => C.named <String>() ;

常规修复

#

如果类型参数是类的类型参数，则将类型参数移动到类名称之后：

dart
class C<T> {
  C.named();
}
C f() => C<String>.named();

如果类型参数不是类的类型参数，则将其删除：

dart
class C<T> {
  C.named();
}
C f() => C.named();

yield_in_non_generator

#

yield 语句必须位于生成器函数中（用 'async*' 或 'sync*' 标记的函数）。

yield-each 语句必须位于生成器函数中（用 'async*' 或 'sync*' 标记的函数）。

说明

#

当 yield 或 yield* 语句出现在其主体未用 async* 或 sync* 修饰符标记的函数中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 yield 用于主体没有修饰符的函数中：

dart
Iterable<int> get digits {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

以下代码会生成此诊断信息，因为 yield* 用于主体具有 async 修饰符而不是 async* 修饰符的函数中：

dart
Stream<int> get digits async {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

常规修复

#

添加修饰符，或将现有修饰符更改为 async* 或 sync* ：

dart
Iterable<int> get digits sync* {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

yield_of_invalid_type

#

类型为 '{0}' 的 yield 值必须可赋值为 '{1}'。

由 'yield*' 表达式隐含的类型 '{0}' 必须可赋值为 '{1}'。

说明

#

当 yield 或 yield* 表达式产生的对象的类型与从生成器（用 sync* 或 async* 标记的函数或方法）返回的 Iterable 或 Stream 类型要返回的对象的类型不匹配时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 getter zero 声明为返回一个返回整数的 Iterable ，但 yield 从可迭代对象中返回一个字符串：

dart
Iterable<int> get zero sync* {
  yield '0';
}

常规修复

#

如果函数的返回类型正确，则修复 yield 关键字后的表达式以返回正确的类型：

dart
Iterable<int> get zero sync* {
  yield 0;
}

如果 yield 后的表达式正确，则更改函数的返回类型以允许它：

dart
Iterable<String> get zero sync* {
  yield '0';
}

always_declare_return_types

#

函数 '{0}' 应具有返回类型，但没有。

方法 '{0}' 应具有返回类型，但没有。

说明

#

当方法或函数没有显式返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 没有返回类型：

dart
f() {}

常规修复

#

添加显式返回类型：

dart
void f() {}

always_put_control_body_on_new_line

#

语句应在单独的行上。

说明

#

当控制流语句 (if 、 for 、 while 或 do) 控制的代码与控制流语句位于同一行时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 return 语句与控制是否执行 return 的 if 位于同一行：

dart
void f(bool b) {
  if (b) return;
}

常规修复

#

将受控语句放在单独的缩进行上：

dart
void f(bool b) {
  if (b)
    return;
}

always_put_required_named_parameters_first

#

必需的命名参数应位于可选命名参数之前。

说明

#

当必需的命名参数出现在可选命名参数之后时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为必需的参数 x 在可选参数 y 之后：

dart
void f({int? y, required int x}) {}

常规修复

#

重新排序参数，以便所有必需的命名参数都位于任何可选命名参数之前：

dart
void f({required int x, int? y}) {}

always_use_package_imports

#

对 'lib' 目录中的文件使用 'package:' 导入。

说明

#

当 lib 目录内的库中的 import 使用相对路径导入同一包的 lib 目录内的另一个库时，分析器会生成此诊断信息。

示例

#

假设名为 a.dart 的文件和下面的代码都在同一包的 lib 目录内，则以下代码会生成此诊断信息，因为它使用了相对 URI 来导入 a.dart ：

dart
import 'a.dart';

常规修复

#

使用包导入：

dart
import 'package:p/a.dart';

annotate_overrides

#

成员 '{0}' 覆盖了继承的成员，但没有用 '@override' 注释。

说明

#

当成员覆盖继承的成员，但没有用 @override 注释时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 B 中的方法 m 覆盖了类 A 中同名的方法，但没有标记为有意的覆盖：

dart
class A {
  void m() {}
}

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

常规修复

#

如果子类中的成员旨在覆盖超类中的成员，则添加 @override 注解：

dart
class A {
  void m() {}
}

class B extends A {
  @override
  void m() {}
}

如果子类中的成员不旨在覆盖超类中的成员，则重命名其中一个成员：

dart
class A {
  void m() {}
}

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

avoid_empty_else

#

在 'else' 子句中不允许使用空语句。

说明

#

当 else 后的语句为空语句（分号）时，分析器会生成此诊断信息。

更多信息，请参见 avoid_empty_else 的文档。

示例

#

以下代码会生成此诊断信息，因为 else 后的语句为空语句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  else ;
    print("2");
}

常规修复

#

如果 else 后的语句旨在仅在条件为 false 时执行，则删除空语句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  else
    print("2");
}

如果没有代码旨在仅在条件为 false 时执行，则删除整个 else 子句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  print("2");
}

avoid_function_literals_in_foreach_calls

#

不应将函数字面量传递给 'forEach'。

说明

#

当 Iterable.forEach 的参数是闭包时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 forEach 的调用的参数是闭包：

dart
void f(Iterable<String> s) {
  s. forEach((e) => print(e));
}

常规修复

#

如果闭包可以用分离来替换，则替换闭包：

dart
void f(Iterable<String> s) {
  s.forEach(print);
}

如果闭包不能用分离来替换，则使用 for 循环来迭代元素：

dart
void f(Iterable<String> s) {
  for (var e in s) {
    print(e);
  }
}

avoid_futureor_void

#

不要使用类型 'FutureOr'。

说明

#

当类型 FutureOr<void> 用作结果类型时（准确地说：它在非逆变的位置使用），分析器会生成此诊断信息。类型 FutureOr<void> 有问题，因为它似乎编码结果是 Future<void> ，或者结果应该被丢弃（当它是 `void如果不需要覆盖任何成员，则删除不必要的覆盖：

dart
class C {
  final int value;

  C(this.value);
}

implementation_imports

#

导入另一个包的 'lib/src' 目录中的库。

说明

#

当导入引用位于另一个包的 lib/src 目录内的库时，分析器会生成此诊断信息，这违反了 pub 包的约定 。

示例

#

以下代码（假设它不是 ffi 包的一部分）会生成此诊断信息，因为导入的库位于顶级 src 目录内：

dart
import 'package:ffi/src/allocation.dart';

常规修复

#

如果导入的库包含公共 API 的一部分代码，则导入导出公共 API 的公共库：

dart
import 'package:ffi/ffi.dart';

如果导入的库不是包的公共 API 的一部分，则找到完成目标的不同方法（如果可能），或打开问题，要求包作者将其作为公共 API 的一部分。

implicit_call_tearoffs

#

隐式分离 'call' 方法。

说明

#

当将具有 call 方法的对象赋值给函数类型的变量时，分析器会生成此诊断信息，这会隐式分离 call 方法。

示例

#

以下代码会生成此诊断信息，因为 Callable 的实例被传递给期望 Function 的函数：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable());
}

常规修复

#

显式分离 call 方法：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable().call);
}

invalid_runtime_check_with_js_interop_types

#

从 '{0}' 到 '{1}' 的强制转换将 Dart 值强制转换为 JS 交互类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为 Dart 类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为不兼容的 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 Dart 值是否为 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 JS 交互值是否为 Dart 类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及两个 JS 交互类型之间的非平凡运行时检查，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及 JS 交互值和不相关的 JS 交互类型之间的运行时检查，这将始终为真，并且不会检查底层类型。

说明

#

当 is 测试具有以下任一情况时，分析器会生成此诊断信息：

  • 右侧为 JS 交互类型，无论是直接还是作为另一个类型的类型参数，或者
  • 左侧为 JS 交互值。

示例

#

以下代码会生成此诊断信息，因为 JS 交互类型 JSBoolean 位于 is 测试的右侧：

dart
import 'dart:js_interop';

bool f(Object b) => b is JSBoolean;

以下代码会生成此诊断信息，因为 JS 交互类型 JSString 用作 is 测试右侧的类型参数：

dart
import 'dart:js_interop';

bool f(List<Object> l) => l is List<JSString>;

以下代码会生成此诊断信息，因为 JS 交互值 a 位于 is 测试的左侧：

dart
import 'dart:js_interop';

bool f(JSAny a) => a is String;

常规修复

#

使用 JS 交互辅助程序（如 isA ）来检查 JS 交互值的底层类型：

dart
import 'dart:js_interop';

void f(Object b) => b.jsify()?.isA<JSBoolean>();

invalid_use_of_do_not_submit_member

#

不应将 '{0}' 的用途提交到源代码控制。

说明

#

当用 @doNotSubmit 注解注释的成员在也用 @doNotSubmit 注释的成员声明之外被引用时，分析器会生成此诊断信息。

示例

#

给定一个包含以下声明的文件 a.dart ：

dart
import 'package:meta/meta.dart';

@doNotSubmit
void emulateCrash() { /* ... */ }

以下代码会生成此诊断信息，因为该声明在也用 @doNotSubmit 注释的成员之外被引用：

dart
import 'a.dart';

void f() {
  emulateCrash() ;
}

常规修复

#

最常见的是，在完成本地测试后，应删除对成员的引用。

如果在成员之上构建附加功能，则也用 @doNotSubmit 注释新添加的成员：

dart
import 'package:meta/meta.dart';

import 'a.dart';

@doNotSubmit
void emulateCrashWithOtherFunctionality() {
  emulateCrash();
  // do other things.
}

library_annotations

#

此注解应附加到库指令。

说明

#

当应用于整个库的注解未与 library 指令关联时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为应用于整个库的 TestOn 注解与 import 指令而不是 library 指令关联：

dart
@TestOn('browser')

import 'package:test/test.dart';

void main() {}

常规修复

#

将注解与 library 指令关联，如有必要，添加一个：

dart
@TestOn('browser')
library;

import 'package:test/test.dart';

void main() {}

library_names

#

库名 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当库的名称未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为库名 libraryName 不是 lower_case_with_underscores 标识符：

dart
library libraryName;

常规修复

#

如果不需要库名，则删除库名：

dart
library;

如果需要库名，则将其转换为使用 lower_case_with_underscores 命名约定：

dart
library library_name;

library_prefixes

#

前缀 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当导入前缀未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为前缀 ffiSupport 不是 lower_case_with_underscores 标识符：

dart
import 'package:ffi/ffi.dart' as ffiSupport;

常规修复

#

将前缀转换为使用 lower_case_with_underscores 命名约定：

dart
import 'package:ffi/ffi.dart' as ffi_support;

library_private_types_in_public_api

#

在公共 API 中无效使用私有类型。

说明

#

当库的公共 API 中引用的类型不是该库的公共 API 的一部分时，分析器会生成此诊断信息。

在公共 API 中使用私有类型可能会使 API 在定义库之外无法使用。

示例

#

以下代码会生成此诊断信息，因为公共函数 f 的参数 c 的类型是库私有的（ _C ）：

dart
void f(_C c) {}

class _C {}

常规修复

#

如果不需要在定义库之外使用 API，则将其设为私有的：

dart
void _f(_C c) {}

class _C {}

如果 API 需要成为库的公共 API 的一部分，则使用不同的公共类型，或使引用的类型成为公共的：

dart
void f(C c) {}

class C {}

literal_only_boolean_expressions

#

布尔表达式的值是常量。

说明

#

当 if 或循环语句中的条件的值已知始终为 true 或始终为 false 时，分析器会生成此诊断信息。对于条件为布尔文字 true 的 while 循环，会例外。

示例

#

以下代码会生成此诊断信息，因为条件将始终计算为 true ：

dart
void f() {
  if (true) {
    print('true');
  }
}

此 lint 将评估由常量组成的表达式的子集，因此以下代码也将生成此诊断信息，因为条件将始终计算为 false ：

dart
void g(int i) {
  if (1 == 0 || 3 > 4) {
    print('false');
  }
}

常规修复

#

如果条件错误，则更正条件，以便在编译时无法知道其值：

dart
void g(int i) {
  if (i == 0 || i > 4) {
    print('false');
  }
}

如果条件正确，则简化代码以不计算条件：

dart
void f() {
  print('true');
}

no_adjacent_strings_in_list

#

不要在列表字面量中使用相邻的字符串。

说明

#

当列表字面量中的两个字符串字面量相邻时，分析器会生成此诊断信息。在 Dart 中，相邻的字符串将连接在一起形成单个字符串，但意图可能是将每个字符串作为列表中的单独元素。

示例

#

以下代码会生成此诊断信息，因为字符串 'a' 和 'b' 相邻：

dart
List<String> list = ['a' 'b', 'c'];

常规修复

#

如果这两个字符串旨在成为列表的单独元素，则在它们之间添加逗号：

dart
List<String> list = ['a', 'b', 'c'];

如果这两个字符串旨在成为单个连接的字符串，则手动合并字符串：

dart
List<String> list = ['ab', 'c'];

或者使用 + 运算符连接字符串：

dart
List<String> list = ['a' + 'b', 'c'];

no_duplicate_case_values

#

case 子句的值 ('{0}') 等于前面 case 子句的值 ('{1}')。

说明

#

当同一 switch 语句中的两个或多个 case 子句具有相同的值时，分析器会生成此诊断信息。

任何第一个 case 子句之后的 case 子句都不能执行，因此具有重复的 case 子句具有误导性。

此诊断信息通常是由于拼写错误或常量值的变化造成的。

示例

#

以下代码会生成此诊断信息，因为两个 case 子句具有相同的值 (1)：

dart
// @dart = 2.14
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 1:
      break;
  }
}

常规修复

#

如果其中一个子句应具有不同的值，则更改子句的值：

dart
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 2:
      break;
  }
}

如果该值正确，则将语句合并到单个子句中：

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

no_leading_underscores_for_library_prefixes

#

库前缀 '{0}' 以下划线开头。

说明

#

当导入上声明的前缀的名称以下划线开头时，分析器会生成此诊断信息。

库前缀在声明库之外本质上是不可见的，因此指示私有的前导下划线不会增加任何价值。

示例

#

以下代码会生成此诊断信息，因为前缀 _core 以下划线开头：

dart
import 'dart:core' as _core;

常规修复

#

删除下划线：

dart
import 'dart:core' as core;

no_leading_underscores_for_local_identifiers

#

局部变量 '{0}' 以下划线开头。

说明

#

如果不需要覆盖任何成员，则删除不必要的覆盖：

dart
class C {
  final int value;

  C(this.value);
}

implementation_imports

#

导入另一个包的 'lib/src' 目录中的库。

说明

#

当导入引用位于另一个包的 lib/src 目录内的库时，分析器会生成此诊断信息，这违反了 pub 包的约定 。

示例

#

以下代码（假设它不是 ffi 包的一部分）会生成此诊断信息，因为导入的库位于顶级 src 目录内：

dart
import 'package:ffi/src/allocation.dart';

常规修复

#

如果导入的库包含公共 API 的一部分代码，则导入导出公共 API 的公共库：

dart
import 'package:ffi/ffi.dart';

如果导入的库不是包的公共 API 的一部分，则找到完成目标的不同方法（如果可能），或打开问题，要求包作者将其作为公共 API 的一部分。

implicit_call_tearoffs

#

隐式分离 'call' 方法。

说明

#

当将具有 call 方法的对象赋值给函数类型的变量时，分析器会生成此诊断信息，这会隐式分离 call 方法。

示例

#

以下代码会生成此诊断信息，因为 Callable 的实例被传递给期望 Function 的函数：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable());
}

常规修复

#

显式分离 call 方法：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable().call);
}

invalid_runtime_check_with_js_interop_types

#

从 '{0}' 到 '{1}' 的强制转换将 Dart 值强制转换为 JS 交互类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为 Dart 类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为不兼容的 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 Dart 值是否为 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 JS 交互值是否为 Dart 类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及两个 JS 交互类型之间的非平凡运行时检查，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及 JS 交互值和不相关的 JS 交互类型之间的运行时检查，这将始终为真，并且不会检查底层类型。

说明

#

当 is 测试具有以下任一情况时，分析器会生成此诊断信息：

  • 右侧为 JS 交互类型，无论是直接还是作为另一个类型的类型参数，或者
  • 左侧为 JS 交互值。

示例

#

以下代码会生成此诊断信息，因为 JS 交互类型 JSBoolean 位于 is 测试的右侧：

dart
import 'dart:js_interop';

bool f(Object b) => b is JSBoolean;

以下代码会生成此诊断信息，因为 JS 交互类型 JSString 用作 is 测试右侧的类型参数：

dart
import 'dart:js_interop';

bool f(List<Object> l) => l is List<JSString>;

以下代码会生成此诊断信息，因为 JS 交互值 a 位于 is 测试的左侧：

dart
import 'dart:js_interop';

bool f(JSAny a) => a is String;

常规修复

#

使用 JS 交互辅助程序（如 isA ）来检查 JS 交互值的底层类型：

dart
import 'dart:js_interop';

void f(Object b) => b.jsify()?.isA<JSBoolean>();

invalid_use_of_do_not_submit_member

#

不应将 '{0}' 的用途提交到源代码控制。

说明

#

当用 @doNotSubmit 注解注释的成员在也用 @doNotSubmit 注释的成员声明之外被引用时，分析器会生成此诊断信息。

示例

#

给定一个包含以下声明的文件 a.dart ：

dart
import 'package:meta/meta.dart';

@doNotSubmit
void emulateCrash() { /* ... */ }

以下代码会生成此诊断信息，因为该声明在也用 @doNotSubmit 注释的成员之外被引用：

dart
import 'a.dart';

void f() {
  emulateCrash() ;
}

常规修复

#

最常见的是，在完成本地测试后，应删除对成员的引用。

如果在成员之上构建附加功能，则也用 @doNotSubmit 注释新添加的成员：

dart
import 'package:meta/meta.dart';

import 'a.dart';

@doNotSubmit
void emulateCrashWithOtherFunctionality() {
  emulateCrash();
  // do other things.
}

library_annotations

#

此注解应附加到库指令。

说明

#

当应用于整个库的注解未与 library 指令关联时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为应用于整个库的 TestOn 注解与 import 指令而不是 library 指令关联：

dart
@TestOn('browser')

import 'package:test/test.dart';

void main() {}

常规修复

#

将注解与 library 指令关联，如有必要，添加一个：

dart
@TestOn('browser')
library;

import 'package:test/test.dart';

void main() {}

library_names

#

库名 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当库的名称未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为库名 libraryName 不是 lower_case_with_underscores 标识符：

dart
library libraryName;

常规修复

#

如果不需要库名，则删除库名：

dart
library;

如果需要库名，则将其转换为使用 lower_case_with_underscores 命名约定：

dart
library library_name;

library_prefixes

#

前缀 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当导入前缀未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为前缀 ffiSupport 不是 lower_case_with_underscores 标识符：

dart
import 'package:ffi/ffi.dart' as ffiSupport;

常规修复

#

将前缀转换为使用 lower_case_with_underscores 命名约定：

dart
import 'package:ffi/ffi.dart' as ffi_support;

library_private_types_in_public_api

#

在公共 API 中无效使用私有类型。

说明

#

当库的公共 API 中引用的类型不是该库的公共 API 的一部分时，分析器会生成此诊断信息。

使用公共 API 中的私有类型可能会使 API 在定义库之外无法使用。

示例

#

以下代码会生成此诊断信息，因为公共函数 f 的参数 c 的类型是库私有的（ _C ）：

dart
void f(_C c) {}

class _C {}

常规修复

#

如果不需要在定义库之外使用 API，则将其设为私有的：

dart
void _f(_C c) {}

class _C {}

如果 API 需要成为库的公共 API 的一部分，则使用不同的公共类型，或使引用的类型成为公共的：

dart
void f(C c) {}

class C {}

literal_only_boolean_expressions

#

布尔表达式的值是常量。

说明

#

当 if 或循环语句中的条件的值已知始终为 true 或始终为 false 时，分析器会生成此诊断信息。对于条件为布尔文字 true 的 while 循环，会例外。

示例

#

以下代码会生成此诊断信息，因为条件将始终计算为 true ：

dart
void f() {
  if (true) {
    print('true');
  }
}

此 lint 将评估由常量组成的表达式的子集，因此以下代码也将生成此诊断信息，因为条件将始终计算为 false ：

dart
void g(int i) {
  if (1 == 0 || 3 > 4) {
    print('false');
  }
}

常规修复

#

如果条件错误，则更正条件，以便在编译时无法知道其值：

dart
void g(int i) {
  if (i == 0 || i > 4) {
    print('false');
  }
}

如果条件正确，则简化代码以不计算条件：

dart
void f() {
  print('true');
}

no_adjacent_strings_in_list

#

不要在列表字面量中使用相邻的字符串。

说明

#

当列表字面量中的两个字符串字面量相邻时，分析器会生成此诊断信息。在 Dart 中，相邻的字符串将连接在一起形成单个字符串，但意图可能是将每个字符串作为列表中的单独元素。

示例

#

以下代码会生成此诊断信息，因为字符串 'a' 和 'b' 相邻：

dart
List<String> list = ['a' 'b', 'c'];

常规修复

#

如果这两个字符串旨在成为列表的单独元素，则在它们之间添加逗号：

dart
List<String> list = ['a', 'b', 'c'];

如果这两个字符串旨在成为单个连接的字符串，则手动合并字符串：

dart
List<String> list = ['ab', 'c'];

或者使用 + 运算符连接字符串：

dart
List<String> list = ['a' + 'b', 'c'];

no_duplicate_case_values

#

case 子句的值 ('{0}') 等于前面 case 子句的值 ('{1}')。

说明

#

当同一 switch 语句中的两个或多个 case 子句具有相同的值时，分析器会生成此诊断信息。

任何第一个 case 子句之后的 case 子句都不能执行，所以具有重复的 case 子句具有误导性。

此诊断信息通常是由于拼写错误或常量值的变化造成的。

示例

#

以下代码会生成此诊断信息，因为两个 case 子句具有相同的值 (1)：

dart
// @dart = 2.14
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 1:
      break;
  }
}

常规修复

#

如果其中一个子句应具有不同的值，则更改子句的值：

dart
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 2:
      break;
  }
}

如果该值正确，则将语句合并到单个子句中：

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

no_leading_underscores_for_library_prefixes

#

库前缀 '{0}' 以下划线开头。

说明

#

当导入上声明的前缀的名称以下划线开头时，分析器会生成此诊断信息。

库前缀在声明库之外本质上是不可见的，所以指示私有的前导下划线不会增加任何价值。

示例

#

以下代码会生成此诊断信息，因为前缀 _core 以下划线开头：

dart
import 'dart:core' as _core;

常规修复

#

删除下划线：

dart
import 'dart:core' as core;

no_leading_underscores_for_local_identifiers

#

局部变量 '{0}' 以下划线开头。

说明

#

当局部变量的名称以下划线开头时，分析器会生成此诊断信息。

局部变量在其声明的库之外本质上是不可见的，因此指示私有的前导下划线不会增加任何价值。

示例

#

以下代码会生成此诊断信息，因为参数 _s 以下划线开头：

dart
int f(String _s) => _s.length;

常规修复

#

删除下划线：

dart
int f(String s) => s.length;

no_logic_in_create_state

#

不要在 'createState' 中放置任何逻辑。

说明

#

当 StatefulWidget 的子类中的 createState 的实现包含除返回调用零参数构造函数的结果以外的任何逻辑时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数调用有参数：

dart
import 'package:flutter/material.dart';

class MyWidget extends StatefulWidget {
  @override
  MyState createState() => MyState(0);
}

class MyState extends State {
  int x;

  MyState(this.x);
}

常规修复

#

重写代码，使 createState 不包含任何逻辑：

dart
import 'package:flutter/material.dart';

class MyWidget extends StatefulWidget {
  @override
  MyState createState() => MyState();
}

class MyState extends State {
  int x = 0;

  MyState();
}

no_wildcard_variable_uses

#

引用的标识符是通配符。

说明

#

当参数或局部变量的名称仅由下划线组成时，分析器会生成此诊断信息。此类名称在未来版本的 Dart 语言中将变为非绑定，从而使引用非法。

示例

#

以下代码会生成此诊断信息，因为参数的名称由两个下划线组成：

dart
// @dart = 3.6
void f(int __) {
  print(__);
}

以下代码会生成此诊断信息，因为局部变量的名称由单个下划线组成：

dart
// @dart = 3.6
void f() {
  int _ = 0;
  print(_);
}

常规修复

#

如果打算引用变量或参数，则为其指定一个至少包含一个非下划线字符的名称：

dart
void f(int p) {
  print(p);
}

如果不需要引用变量或参数，则将引用替换为不同的表达式：

dart
void f() {
  print(0);
}

non_constant_identifier_names

#

变量名 '{0}' 不是 lowerCamelCase 标识符。

说明

#

当类成员、顶级声明、变量、参数、命名参数或未声明为 const 的命名构造函数的名称不使用 lowerCamelCase 约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级变量 Count 没有以小写字母开头：

dart
var Count = 0;

常规修复

#

更改声明中的名称以遵循 lowerCamelCase 约定：

dart
var count = 0;

null_check_on_nullable_type_parameter

#

不应在类型为潜在可空类型参数的变量上使用空检查运算符。

说明

#

当在类型为 T? 的变量上使用空检查运算符时，分析器会生成此诊断信息，其中 T 是一个类型参数，允许类型参数为空（没有边界或边界为空）。

给定一个具有可空边界的泛型类型参数 T ，在使用类型为 T? 的变量时，很容易引入错误的空检查。具体来说，拥有 T? x; 并想要断言 x 已被设置为类型 T 的有效值的情况并不少见。常见的错误是使用 x! 来做到这一点。这几乎总是不正确的，因为如果 T 是可空类型，则 x 可以有效地保存 null 作为类型 T 的值。

示例

#

以下代码会生成此诊断信息，因为 t 的类型为 T? ，而 T 允许类型参数为空（因为它没有 extends 子句）：

dart
T f<T>(T? t) => t!;

常规修复

#

使用类型参数强制转换变量：

dart
T f<T>(T? t) => t as T;

overridden_fields

#

字段覆盖从 '{0}' 继承的字段。

说明

#

当类定义覆盖超类中字段的字段时，分析器会生成此诊断信息。

用另一个字段覆盖字段会导致对象具有两个不同的字段，但由于字段具有相同的名称，因此只能在一个给定的作用域中引用其中一个字段。这可能会导致混淆，其中对其中一个字段的引用可能被误认为是对另一个字段的引用。

示例

#

以下代码会生成此诊断信息，因为 B 中的字段 f 遮蔽了 A 中的字段 f ：

dart
class A {
  int f = 1;
}

class B extends A {
  @override
  int f = 2;
}

常规修复

#

如果这两个字段表示相同的属性，则从子类中删除该字段：

dart
class A {
  int f = 1;
}

class B extends A {}

如果这两个字段应该不同，则重命名其中一个字段：

dart
class A {
  int f = 1;
}

class B extends A {
  int g = 2;
}

如果这两个字段以某种方式相关，但不能相同，则找到实现所需语义的不同方法。

package_names

#

包名 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当包的名称未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为包的名称使用 lowerCamelCase 命名约定：

yaml
name: somePackage

常规修复

#

使用 lower_case_with_underscores 命名约定重写包的名称：

yaml
name: some_package

package_prefixed_library_names

#

库名不是包名前缀的点分隔路径。

说明

#

当库的名称不遵循以下准则时，分析器会生成此诊断信息：

  • 将所有库名称名前缀加上包名称。
  • 使入口库的名称与包的名称相同。
  • 对于包中的所有其他库，在包名称后添加库的 Dart 文件的点分隔路径。
  • 对于 lib 下的库，省略顶级目录名称。

例如，给定一个名为 my_package 的包，以下是包中各种文件的库名称：

示例

#

假设包含以下代码的文件不在名为 special.dart 的文件中，该文件位于名为 something 的包的 lib 目录中（这将是该规则的例外），分析器会生成此诊断信息，因为库的名称不符合上述准则：

dart
library something.special;

常规修复

#

更改库的名称以符合准则。

prefer_adjacent_string_concatenation

#

字符串字面量不应通过 '+' 运算符连接。

说明

#

当使用 + 运算符连接两个字符串字面量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为两个字符串字面量正在使用 + 运算符连接：

dart
var s = 'a' + 'b';

常规修复

#

删除运算符：

dart
var s = 'a' 'b';

prefer_collection_literals

#

不必要的构造函数调用。

说明

#

当使用构造函数创建列表、映射或集合时，分析器会生成此诊断信息，但字面量会产生相同的结果。

示例

#

以下代码会生成此诊断信息，因为正在使用 Map 的构造函数创建一个也可以使用字面量创建的映射：

dart
var m = Map<String, String>();

常规修复

#

使用字面量表示：

dart
var m = <String, String>{};

prefer_conditional_assignment

#

'if' 语句可以用空感知赋值替换。

说明

#

当对变量的赋值基于变量的值是否为 null ，并且可以使用 ??= 运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为参数 s 正在与 null 进行比较，以确定是否要赋值不同的值：

dart
int f(String? s) {
  if (s == null) {
    s = '';
  }
  return s.length;
}

常规修复

#

使用 ??= 运算符代替显式的 if 语句：

dart
int f(String? s) {
  s ??= '';
  return s.length;
}

prefer_const_constructors

#

用 'const' 和构造函数来提高性能。

说明

#

当 const 构造函数的调用既没有 const 为前缀，也不在 常量上下文 中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 const 构造函数的调用既没有 const 为前缀，也不在 常量上下文 中：

dart
class C {
  const C();
}

C c = C();

常规修复

#

如果上下文可以成为 常量上下文 ，则这样做：

dart
class C {
  const C();
}

const C c = C();

如果上下文不能成为 常量上下文 ，则在构造函数调用前添加 const ：

dart
class C {
  const C();
}

C c = const C();

prefer_const_constructors_in_immutables

#

'@immutable' 类中的构造函数应声明为 'const'。

说明

#

当在具有 @immutable 注解的类中找到非 const 构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 中的构造函数没有声明为 const ，即使 C 有 @immutable 注解：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  C(this.f) ;
}

常规修复

#

如果该类确实旨在为不可变的，则向构造函数添加 const 修饰符：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

如果该类是可变的，则删除 @immutable 注解：

dart
class C {
  final f;

  C(this.f);
}

prefer_const_declarations

#

对初始化为常量值的 final 变量使用 'const'。

说明

#

当顶级变量、静态字段或局部变量被标记为 final 并初始化为常量值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级变量 v 既是 final ，又初始化为常量值：

dart
final v = const <int>[];

以下代码会生成此诊断信息，因为静态字段 f 既是 final ，又初始化为常量值：

dart
class C {
  static final f = const <int>[];
}

以下代码会生成此诊断信息，因为局部变量 v 既是 final ，又初始化为常量值：

dart
void f() {
  final v = const <int>[];
  print(v);
}

常规修复

#

将关键字 final 替换为 const 并从初始化器中删除 const ：

dart
class C {
  static const f = <int>[];
}

prefer_const_literals_to_create_immutables

#

使用 'const' 字面量作为 '@immutable' 类的构造函数的参数。

说明

#

当将非 const 列表、映射或集合字面量作为参数传递给用 @immutable 注释的类中声明的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为列表字面量

如果不需要覆盖任何成员，则删除不必要的覆盖：

dart
class C {
  final int value;

  C(this.value);
}

implementation_imports

#

导入另一个包的“lib/src”目录中的库。

说明

#

当导入引用位于另一个包的 lib/src 目录内的库时，分析器会生成此诊断信息，这违反了 pub 包的约定 。

示例

#

以下代码（假设它不是 ffi 包的一部分）会生成此诊断信息，因为导入的库位于顶级 src 目录内：

dart
import 'package:ffi/src/allocation.dart';

常规修复

#

如果导入的库包含公共 API 的一部分代码，则导入导出公共 API 的公共库：

dart
import 'package:ffi/ffi.dart';

如果导入的库不是包的公共 API 的一部分，则找到完成目标的不同方法（如果可能），或打开问题，要求包作者将其作为公共 API 的一部分。

implicit_call_tearoffs

#

隐式分离“call”方法。

说明

#

当将具有 call 方法的对象赋值给函数类型的变量时，分析器会生成此诊断信息，这会隐式分离 call 方法。

示例

#

以下代码会生成此诊断信息，因为 Callable 的实例被传递给期望 Function 的函数：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable());
}

常规修复

#

显式分离 call 方法：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable().call);
}

invalid_runtime_check_with_js_interop_types

#

从 '{0}' 到 '{1}' 的强制转换将 Dart 值强制转换为 JS 交互类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为 Dart 类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为不兼容的 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 Dart 值是否为 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 JS 交互值是否为 Dart 类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及两个 JS 交互类型之间的非平凡运行时检查，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及 JS 交互值和不相关的 JS 交互类型之间的运行时检查，这将始终为真，并且不会检查底层类型。

说明

#

当 is 测试具有以下任一情况时，分析器会生成此诊断信息：

  • 右侧为 JS 交互类型，无论是直接还是作为另一个类型的类型参数，或者
  • 左侧为 JS 交互值。

示例

#

以下代码会生成此诊断信息，因为 JS 交互类型 JSBoolean 位于 is 测试的右侧：

dart
import 'dart:js_interop';

bool f(Object b) => b is JSBoolean;

以下代码会生成此诊断信息，因为 JS 交互类型 JSString 用作 is 测试右侧的类型参数：

dart
import 'dart:js_interop';

bool f(List<Object> l) => l is List<JSString>;

以下代码会生成此诊断信息，因为 JS 交互值 a 位于 is 测试的左侧：

dart
import 'dart:js_interop';

bool f(JSAny a) => a is String;

常规修复

#

使用 JS 交互辅助程序（如 isA ）来检查 JS 交互值的底层类型：

dart
import 'dart:js_interop';

void f(Object b) => b.jsify()?.isA<JSBoolean>();

invalid_use_of_do_not_submit_member

#

不应将 '{0}' 的用途提交到源代码控制。

说明

#

当用 @doNotSubmit 注解注释的成员在也用 @doNotSubmit 注释的成员声明之外被引用时，分析器会生成此诊断信息。

示例

#

给定一个包含以下声明的文件 a.dart ：

dart
import 'package:meta/meta.dart';

@doNotSubmit
void emulateCrash() { /* ... */ }

以下代码会生成此诊断信息，因为该声明在也用 @doNotSubmit 注释的成员之外被引用：

dart
import 'a.dart';

void f() {
  emulateCrash() ;
}

常规修复

#

最常见的是，在完成本地测试后，应删除对成员的引用。

如果在成员之上构建附加功能，则也用 @doNotSubmit 注释新添加的成员：

dart
import 'package:meta/meta.dart';

import 'a.dart';

@doNotSubmit
void emulateCrashWithOtherFunctionality() {
  emulateCrash();
  // do other things.
}

library_annotations

#

此注解应附加到库指令。

说明

#

当应用于整个库的注解未与 library 指令关联时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为应用于整个库的 TestOn 注解与 import 指令而不是 library 指令关联：

dart
@TestOn('browser')

import 'package:test/test.dart';

void main() {}

常规修复

#

将注解与 library 指令关联，如有必要，添加一个：

dart
@TestOn('browser')
library;

import 'package:test/test.dart';

void main() {}

library_names

#

库名 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当库的名称未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为库名 libraryName 不是 lower_case_with_underscores 标识符：

dart
library libraryName;

常规修复

#

如果不需要库名，则删除库名：

dart
library;

如果需要库名，则将其转换为使用 lower_case_with_underscores 命名约定：

dart
library library_name;

library_prefixes

#

前缀 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当导入前缀未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为前缀 ffiSupport 不是 lower_case_with_underscores 标识符：

dart
import 'package:ffi/ffi.dart' as ffiSupport;

常规修复

#

将前缀转换为使用 lower_case_with_underscores 命名约定：

dart
import 'package:ffi/ffi.dart' as ffi_support;

library_private_types_in_public_api

#

在公共 API 中无效使用私有类型。

说明

#

当库的公共 API 中引用的类型不是该库的公共 API 的一部分时，分析器会生成此诊断信息。

使用公共 API 中的私有类型可能会使 API 在定义库之外无法使用。

示例

#

以下代码会生成此诊断信息，因为公共函数 f 的参数 c 的类型是库私有的（ _C ）：

dart
void f(_C c) {}

class _C {}

常规修复

#

如果不需要在定义库之外使用 API，则将其设为私有的：

dart
void _f(_C c) {}

class _C {}

如果 API 需要成为库的公共 API 的一部分，则使用不同的公共类型，或使引用的类型成为公共的：

dart
void f(C c) {}

class C {}

literal_only_boolean_expressions

#

布尔表达式的值是常量。

说明

#

当 if 或循环语句中的条件的值已知始终为 true 或始终为 false 时，分析器会生成此诊断信息。对于条件为布尔文字 true 的 while 循环，会例外。

示例

#

以下代码会生成此诊断信息，因为条件将始终计算为 true ：

dart
void f() {
  if (true) {
    print('true');
  }
}

此 lint 将评估由常量组成的表达式的子集，因此以下代码也将生成此诊断信息，因为条件将始终计算为 false ：

dart
void g(int i) {
  if (1 == 0 || 3 > 4) {
    print('false');
  }
}

常规修复

#

如果条件错误，则更正条件，以便在编译时无法知道其值：

dart
void g(int i) {
  if (i == 0 || i > 4) {
    print('false');
  }
}

如果条件正确，则简化代码以不计算条件：

dart
void f() {
  print('true');
}

no_adjacent_strings_in_list

#

不要在列表字面量中使用相邻的字符串。

说明

#

当列表字面量中的两个字符串字面量相邻时，分析器会生成此诊断信息。在 Dart 中，相邻的字符串将连接在一起形成单个字符串，但意图可能是将每个字符串作为列表中的单独元素。

示例

#

以下代码会生成此诊断信息，因为字符串 'a' 和 'b' 相邻：

dart
List<String> list = ['a' 'b', 'c'];

常规修复

#

如果这两个字符串旨在成为列表的单独元素，则在它们之间添加逗号：

dart
List<String> list = ['a', 'b', 'c'];

如果这两个字符串旨在成为单个连接的字符串，则手动合并字符串：

dart
List<String> list = ['ab', 'c'];

或者使用 + 运算符连接字符串：

dart
List<String> list = ['a' + 'b', 'c'];

no_duplicate_case_values

#

case 子句的值 ('{0}') 等于前面 case 子句的值 ('{1}')。

说明

#

当同一 switch 语句中的两个或多个 case 子句具有相同的值时，分析器会生成此诊断信息。

任何第一个 case 子句之后的 case 子句都不能执行，所以具有重复的 case 子句具有误导性。

此诊断信息通常是由于拼写错误或常量值的变化造成的。

示例

#

以下代码会生成此诊断信息，因为两个 case 子句具有相同的值 (1)：

dart
// @dart = 2.14
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 1:
      break;
  }
}

常规修复

#

如果其中一个子句应具有不同的值，则更改子句的值：

dart
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 2:
      break;
  }
}

如果该值正确，则将语句合并到单个子句中：

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

no_leading_underscores_for_library_prefixes

#

库前缀 '{0}' 以下划线开头。

说明

#

当导入上声明的前缀的名称以下划线开头时，分析器会生成此诊断信息。

库前缀在声明库之外本质上是不可见的，所以指示私有的前导下划线不会增加任何价值。

示例

#

以下代码会生成此诊断信息，因为前缀 _core 以下划线开头：

dart
import 'dart:core' as _core;

常规修复

#

删除下划线：

dart
import 'dart:core' as core;

no_leading_underscores_for_local_identifiers

#

局部变量 '{0}' 以下划线开头。

说明

#

当局部变量的名称以下划线开头时，分析器会生成此诊断信息。

局部变量在其声明的库之外本质上是不可见的，因此指示私有的前导下划线不会增加任何价值。

示例

#

以下代码会生成此诊断信息，因为参数 _s 以下划线开头：

dart
int f(String _s) => _s.length;

常规修复

#

删除下划线：

dart
int f(String s) => s.length;

no_logic_in_create_state

#

不要在 'createState' 中放置任何逻辑。

说明

#

当 StatefulWidget 的子类中的 createState 的实现包含除返回调用零参数构造函数的结果以外的任何逻辑时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数调用有参数：

dart
import 'package:flutter/material.dart';

class MyWidget extends StatefulWidget {
  @override
  MyState createState() => MyState(0);
}

class MyState extends State {
  int x;

  MyState(this.x);
}

常规修复

#

重写代码，使 createState 不包含任何逻辑：

dart
import 'package:flutter/material.dart';

class MyWidget extends StatefulWidget {
  @override
  MyState createState() => MyState();
}

class MyState extends State {
  int x = 0;

  MyState();
}

no_wildcard_variable_uses

#

引用的标识符是通配符。

说明

#

当参数或局部变量的名称仅由下划线组成时，分析器会生成此诊断信息。此类名称在未来版本的 Dart 语言中将变为非绑定，从而使引用非法。

示例

#

以下代码会生成此诊断信息，因为参数的名称由两个下划线组成：

dart
// @dart = 3.6
void f(int __) {
  print(__);
}

以下代码会生成此诊断信息，因为局部变量的名称由单个下划线组成：

dart
// @dart = 3.6
void f() {
  int _ = 0;
  print(_);
}

常规修复

#

如果打算引用变量或参数，则为其指定一个至少包含一个非下划线字符的名称：

dart
void f(int p) {
  print(p);
}

如果不需要引用变量或参数，则将引用替换为不同的表达式：

dart
void f() {
  print(0);
}

non_constant_identifier_names

#

变量名 '{0}' 不是 lowerCamelCase 标识符。

说明

#

当类成员、顶级声明、变量、参数、命名参数或未声明为 const 的命名构造函数的名称不使用 lowerCamelCase 约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级变量 Count 没有以小写字母开头：

dart
var Count = 0;

常规修复

#

更改声明中的名称以遵循 lowerCamelCase 约定：

dart
var count = 0;

null_check_on_nullable_type_parameter

#

不应在类型为潜在可空类型参数的变量上使用空检查运算符。

说明

#

当在类型为 T? 的变量上使用空检查运算符时，分析器会生成此诊断信息，其中 T 是一个类型参数，允许类型参数为空（没有边界或边界为空）。

给定一个具有可空边界的泛型类型参数 T ，在使用类型为 T? 的变量时，很容易引入错误的空检查。具体来说，拥有 T? x; 并想要断言 x 已被设置为类型 T 的有效值的情况并不少见。常见的错误是使用 x! 来做到这一点。这几乎总是不正确的，因为如果 T 是可空类型，则 x 可以有效地保存 null 作为类型 T 的值。

示例

#

以下代码会生成此诊断信息，因为 t 的类型为 T? ，而 T 允许类型参数为空（因为它没有 extends 子句）：

dart
T f<T>(T? t) => t!;

常规修复

#

使用类型参数强制转换变量：

dart
T f<T>(T? t) => t as T;

overridden_fields

#

字段覆盖从 '{0}' 继承的字段。

说明

#

当类定义覆盖超类中字段的字段时，分析器会生成此诊断信息。

用另一个字段覆盖字段会导致对象具有两个不同的字段，但由于字段具有相同的名称，因此只能在一个给定的作用域中引用其中一个字段。这可能会导致混淆，其中对其中一个字段的引用可能被误认为是对另一个字段的引用。

示例

#

以下代码会生成此诊断信息，因为 B 中的字段 f 遮蔽了 A 中的字段 f ：

dart
class A {
  int f = 1;
}

class B extends A {
  @override
  int f = 2;
}

常规修复

#

如果这两个字段表示相同的属性，则从子类中删除该字段：

dart
class A {
  int f = 1;
}

class B extends A {}

如果这两个字段应该不同，则重命名其中一个字段：

dart
class A {
  int f = 1;
}

class B extends A {
  int g = 2;
}

如果这两个字段以某种方式相关，但不能相同，则找到实现所需语义的不同方法。

package_names

#

包名 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当包的名称未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为包的名称使用 lowerCamelCase 命名约定：

yaml
name: somePackage

常规修复

#

使用 lower_case_with_underscores 命名约定重写包的名称：

yaml
name: some_package

package_prefixed_library_names

#

库名不是包名前缀的点分隔路径。

说明

#

当库的名称不遵循以下准则时，分析器会生成此诊断信息：

  • 将所有库名称名前缀加上包名称。
  • 使入口库的名称与包的名称相同。
  • 对于包中的所有其他库，在包名称后添加库的 Dart 文件的点分隔路径。
  • 对于 lib 下的库，省略顶级目录名称。

例如，给定一个名为 my_package 的包，以下是包中各种文件的库名称：

示例

#

假设包含以下代码的文件不在名为 special.dart 的文件中，该文件位于名为 something 的包的 lib 目录中（这将是该规则的例外），分析器会生成此诊断信息，因为库的名称不符合上述准则：

dart
library something.special;

常规修复

#

更改库的名称以符合准则。

prefer_adjacent_string_concatenation

#

字符串字面量不应通过 '+' 运算符连接。

说明

#

当使用 + 运算符连接两个字符串字面量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为两个字符串字面量正在使用 + 运算符连接：

dart
var s = 'a' + 'b';

常规修复

#

删除运算符：

dart
var s = 'a' 'b';

prefer_collection_literals

#

不必要的构造函数调用。

说明

#

当使用构造函数创建列表、映射或集合时，分析器会生成此诊断信息，但字面量会产生相同的结果。

示例

#

以下代码会生成此诊断信息，因为 Map 的构造函数用于创建也可以使用字面量创建的映射：

dart
var m = Map<String, String>();

常规修复

#

使用字面量表示：

dart
var m = <String, String>{};

prefer_conditional_assignment

#

'if' 语句可以用空感知赋值替换。

说明

#

当对变量的赋值基于变量的值是否为 null ，并且可以使用 ??= 运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为参数 s 正在与 null 进行比较，以确定是否要赋值不同的值：

dart
int f(String? s) {
  if (s == null) {
    s = '';
  }
  return s.length;
}

常规修复

#

使用 ??= 运算符代替显式的 if 语句：

dart
int f(String? s) {
  s ??= '';
  return s.length;
}

prefer_const_constructors

#

用 'const' 和构造函数来提高性能。

说明

#

当 const 构造函数的调用既没有 const 为前缀，也不在 常量上下文 中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 const 构造函数的调用既没有 const 为前缀，也不在 常量上下文 中：

dart
class C {
  const C();
}

C c = C();

常规修复

#

如果上下文可以成为 常量上下文 ，则这样做：

dart
class C {
  const C();
}

const C c = C();

如果上下文不能成为 常量上下文 ，则在构造函数调用前添加 const ：

dart
class C {
  const C();
}

C c = const C();

prefer_const_constructors_in_immutables

#

'@immutable' 类中的构造函数应声明为 'const'。

说明

#

当在具有 @immutable 注解的类中找到非 const 构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 中的构造函数没有声明为 const ，即使 C 有 @immutable 注解：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  C(this.f) ;
}

常规修复

#

如果该类确实旨在为不可变的，则向构造函数添加 const 修饰符：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

如果该类是可变的，则删除 @immutable 注解：

dart
class C {
  final f;

  C(this.f);
}

prefer_const_declarations

#

对初始化为常量值的 final 变量使用 'const'。

说明

#

当顶级变量、静态字段或局部变量被标记为 final 并初始化为常量值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级变量 v 既是 final ，又初始化为常量值：

dart
final v = const <int>[];

以下代码会生成此诊断信息，因为静态字段 f 既是 final ，又初始化为常量值：

dart
class C {
  static final f = const <int>[];
}

以下代码会生成此诊断信息，因为局部变量 v 既是 final ，又初始化为常量值：

dart
void f() {
  final v = const <int>[];
  print(v);
}

常规修复

#

将关键字 final 替换为 const 并从初始化器中删除 const ：

dart
class C {
  static const f = <int>[];
}

prefer_const_literals_to_create_immutables

#

使用 'const' 字面量作为 '@immutable' 类的构造函数的参数。

说明

#

当将非 const 列表、映射或集合字面量作为参数传递给用 @immutable 注释的类中声明的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为列表字面量

([1]) is being passed to a constructor in an immutable class but isn't a constant list:

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

C c = C([1]);

常规修复

#

如果上下文可以成为 常量上下文 ，则这样做：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

const C c = C([1]);

如果上下文不能成为 常量上下文 ，但可以使用 const 调用构造函数，则在构造函数调用之前添加 const ：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

C c = const C([1]);

如果上下文不能成为 常量上下文 ，并且不能使用 const 调用构造函数，则在集合字面量之前添加关键字 const ：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

C c = C(const [1]);

prefer_contains

#

始终为 'false'，因为 'indexOf' 始终大于或等于 -1。

始终为 'true'，因为 'indexOf' 始终大于或等于 -1。

不必要地使用 'indexOf' 来测试是否包含。

说明

#

当使用 indexOf 方法并且结果仅以语义等效于使用 contains 的方式与 -1 或 0 进行比较时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 if 语句中的条件正在检查列表是否包含该字符串：

dart
void f(List<String> l, String s) {
  if (l.indexOf(s) < 0) {
    // ...
  }
}

常规修复

#

使用 contains 代替，如有必要，否定条件：

dart
void f(List<String> l, String s) {
  if (l.contains(s)) {
    // ...
  }
}

prefer_double_quotes

#

不必要地使用单引号。

说明

#

当字符串字面量使用单引号 (') 而可以使用双引号 (")，并且不需要额外的转义符，并且不会影响可读性时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字符串字面量使用单引号，但没有必要：

dart
void f(String name) {
  print('Hello $name');
}

常规修复

#

用双引号代替单引号：

dart
void f(String name) {
  print("Hello $name");
}

prefer_final_fields

#

私有字段 {0} 可以是 'final'。

说明

#

当私有字段只赋值一次时，分析器会生成此诊断信息。该字段可以在多个构造函数中初始化，仍然会被标记，因为这些构造函数中只有一个可以运行。

示例

#

以下代码会生成此诊断信息，因为字段 _f 只赋值一次，在字段的初始化器中：

dart
class C {
  int _f = 1;

  int get f => _f;
}

常规修复

#

将字段标记为 final ：

dart
class C {
  final int _f = 1;

  int get f => _f;
}

prefer_for_elements_to_map_fromiterable

#

从可迭代对象构建映射时，使用 'for' 元素。

说明

#

当使用 Map.fromIterable 构建可以使用 for 元素构建的映射时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 fromIterable 用于构建可以使用 for 元素构建的映射：

dart
void f(Iterable<String> data) {
  Map<String, int>.fromIterable(
    data,
    key: (element) => element,
    value: (element) => element.length,
  );
}

常规修复

#

使用 for 元素构建映射：

dart
void f(Iterable<String> data) {
  <String, int>{
    for (var element in data)
      element: element.length
  };
}

prefer_function_declarations_over_variables

#

使用函数声明而不是变量赋值将函数绑定到名称。

说明

#

当闭包被赋值给局部变量，并且局部变量在任何地方都没有被重新赋值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为局部变量 f 被初始化为闭包，并且没有被赋值任何其他值：

dart
void g() {
  var f = (int i) => i * 2;
  f(1);
}

常规修复

#

将局部变量替换为局部函数：

dart
void g() {
  int f(int i) => i * 2;
  f(1);
}

prefer_generic_function_type_aliases

#

在 'typedef' 中使用泛型函数类型语法。

说明

#

当使用旧的函数类型别名语法编写 typedef 时，分析器会生成此诊断信息，在该语法中，声明的名称嵌入在函数类型中。

示例

#

以下代码会生成此诊断信息，因为它使用了旧的语法：

dart
typedef void F<T>();

常规修复

#

重写 typedef 以使用较新的语法：

dart
typedef F<T> = void Function();

prefer_if_null_operators

#

在测试 'null' 时，使用 '??' 运算符而不是 '?:'。

说明

#

当使用条件表达式（使用 ?: 运算符）在局部变量为 null 时选择不同的值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 s 正在与 null 进行比较，以便在 s 为 null 时返回不同的值：

dart
String f(String? s) => s == null ? '' : s;

常规修复

#

使用 if-null 运算符代替：

dart
String f(String? s) => s ?? '';

prefer_initializing_formals

#

使用初始化形式参数将参数赋值给字段。

说明

#

当构造函数参数用于初始化字段而无需修改时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为参数 c 仅用于设置字段 c ：

dart
class C {
  int c;

  C(int c) : this.c = c;
}

常规修复

#

使用初始化形式参数初始化字段：

dart
class C {
  int c;

  C(this.c);
}

prefer_inlined_adds

#

可以内联列表项的添加。

可以内联多个列表项的添加。

说明

#

当在列表字面量上调用 add 和 addAll 方法，并且可以将要添加的元素包含在列表字面量中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为正在使用 add 方法添加 b ，而它可以直接包含在列表字面量中：

dart
List<String> f(String a, String b) {
  return [a].. add(b) ;
}

以下代码会生成此诊断信息，因为正在使用 addAll 方法添加 b 的元素，而它可以直接包含在列表字面量中：

dart
List<String> f(String a, List<String> b) {
  return [a].. addAll(b) ;
}

常规修复

#

如果正在使用 add 方法，则使参数成为列表的元素并删除调用：

dart
List<String> f(String a, String b) {
  return [a, b];
}

如果正在使用 addAll 方法，则在参数上使用展开运算符将其元素添加到列表中并删除调用：

dart
List<String> f(String a, List<String> b) {
  return [a, ...b];
}

prefer_interpolation_to_compose_strings

#

使用插值来组合字符串和值。

说明

#

当使用 + 运算符连接字符串字面量和计算的字符串时，分析器会生成此诊断信息，但字符串插值将达到相同的结果。

示例

#

以下代码会生成此诊断信息，因为字符串如果不需要覆盖任何成员，则删除不必要的覆盖：

dart
class C {
  final int value;

  C(this.value);
}

implementation_imports

#

导入另一个包的“lib/src”目录中的库。

说明

#

当导入引用位于另一个包的 lib/src 目录内的库时，分析器会生成此诊断信息，这违反了 pub 包的约定 。

示例

#

以下代码（假设它不是 ffi 包的一部分）会生成此诊断信息，因为导入的库位于顶级 src 目录内：

dart
import 'package:ffi/src/allocation.dart';

常规修复

#

如果导入的库包含公共 API 的一部分代码，则导入导出公共 API 的公共库：

dart
import 'package:ffi/ffi.dart';

如果导入的库不是包的公共 API 的一部分，则找到完成目标的不同方法（如果可能），或打开问题，要求包作者将其作为公共 API 的一部分。

implicit_call_tearoffs

#

隐式分离“call”方法。

说明

#

当将具有 call 方法的对象赋值给函数类型的变量时，分析器会生成此诊断信息，这会隐式分离 call 方法。

示例

#

以下代码会生成此诊断信息，因为 Callable 的实例被传递给期望 Function 的函数：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable());
}

常规修复

#

显式分离 call 方法：

dart
class Callable {
  void call() {}
}

void callIt(void Function() f) {
  f();
}

void f() {
  callIt(Callable().call);
}

invalid_runtime_check_with_js_interop_types

#

从 '{0}' 到 '{1}' 的强制转换将 Dart 值强制转换为 JS 交互类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为 Dart 类型，这可能不是平台一致的。

从 '{0}' 到 '{1}' 的强制转换将 JS 交互值强制转换为不兼容的 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 Dart 值是否为 JS 交互类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查会检查 JS 交互值是否为 Dart 类型，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及两个 JS 交互类型之间的非平凡运行时检查，这可能不是平台一致的。

在 '{0}' 和 '{1}' 之间的运行时检查涉及 JS 交互值和不相关的 JS 交互类型之间的运行时检查，这将始终为真，并且不会检查底层类型。

说明

#

当 is 测试具有以下任一情况时，分析器会生成此诊断信息：

  • 右侧为 JS 交互类型，无论是直接还是作为另一个类型的类型参数，或者
  • 左侧为 JS 交互值。

示例

#

以下代码会生成此诊断信息，因为 JS 交互类型 JSBoolean 位于 is 测试的右侧：

dart
import 'dart:js_interop';

bool f(Object b) => b is JSBoolean;

以下代码会生成此诊断信息，因为 JS 交互类型 JSString 用作 is 测试右侧的类型参数：

dart
import 'dart:js_interop';

bool f(List<Object> l) => l is List<JSString>;

以下代码会生成此诊断信息，因为 JS 交互值 a 位于 is 测试的左侧：

dart
import 'dart:js_interop';

bool f(JSAny a) => a is String;

常规修复

#

使用 JS 交互辅助程序（如 isA ）来检查 JS 交互值的底层类型：

dart
import 'dart:js_interop';

void f(Object b) => b.jsify()?.isA<JSBoolean>();

invalid_use_of_do_not_submit_member

#

不应将 '{0}' 的用途提交到源代码控制。

说明

#

当用 @doNotSubmit 注解注释的成员在也用 @doNotSubmit 注释的成员声明之外被引用时，分析器会生成此诊断信息。

示例

#

给定一个包含以下声明的文件 a.dart ：

dart
import 'package:meta/meta.dart';

@doNotSubmit
void emulateCrash() { /* ... */ }

以下代码会生成此诊断信息，因为该声明在也用 @doNotSubmit 注释的成员之外被引用：

dart
import 'a.dart';

void f() {
  emulateCrash() ;
}

常规修复

#

最常见的是，在完成本地测试后，应删除对成员的引用。

如果在成员之上构建附加功能，则也用 @doNotSubmit 注释新添加的成员：

dart
import 'package:meta/meta.dart';

import 'a.dart';

@doNotSubmit
void emulateCrashWithOtherFunctionality() {
  emulateCrash();
  // do other things.
}

library_annotations

#

此注解应附加到库指令。

说明

#

当应用于整个库的注解未与 library 指令关联时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为应用于整个库的 TestOn 注解与 import 指令而不是 library 指令关联：

dart
@TestOn('browser')

import 'package:test/test.dart';

void main() {}

常规修复

#

将注解与 library 指令关联，如有必要，添加一个：

dart
@TestOn('browser')
library;

import 'package:test/test.dart';

void main() {}

library_names

#

库名 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当库的名称未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为库名 libraryName 不是 lower_case_with_underscores 标识符：

dart
library libraryName;

常规修复

#

如果不需要库名，则删除库名：

dart
library;

如果需要库名，则将其转换为使用 lower_case_with_underscores 命名约定：

dart
library library_name;

library_prefixes

#

前缀 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当导入前缀未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为前缀 ffiSupport 不是 lower_case_with_underscores 标识符：

dart
import 'package:ffi/ffi.dart' as ffiSupport;

常规修复

#

将前缀转换为使用 lower_case_with_underscores 命名约定：

dart
import 'package:ffi/ffi.dart' as ffi_support;

library_private_types_in_public_api

#

在公共 API 中无效使用私有类型。

说明

#

当库的公共 API 中引用的类型不是该库的公共 API 的一部分时，分析器会生成此诊断信息。

使用公共 API 中的私有类型可能会使 API 在定义库之外无法使用。

示例

#

以下代码会生成此诊断信息，因为公共函数 f 的参数 c 的类型是库私有的（ _C ）：

dart
void f(_C c) {}

class _C {}

常规修复

#

如果不需要在定义库之外使用 API，则将其设为私有的：

dart
void _f(_C c) {}

class _C {}

如果 API 需要成为库的公共 API 的一部分，则使用不同的公共类型，或使引用的类型成为公共的：

dart
void f(C c) {}

class C {}

literal_only_boolean_expressions

#

布尔表达式的值是常量。

说明

#

当 if 或循环语句中的条件的值已知始终为 true 或始终为 false 时，分析器会生成此诊断信息。对于条件为布尔文字 true 的 while 循环，会例外。

示例

#

以下代码会生成此诊断信息，因为条件将始终计算为 true ：

dart
void f() {
  if (true) {
    print('true');
  }
}

此 lint 将评估由常量组成的表达式的子集，因此以下代码也将生成此诊断信息，因为条件将始终计算为 false ：

dart
void g(int i) {
  if (1 == 0 || 3 > 4) {
    print('false');
  }
}

常规修复

#

如果条件错误，则更正条件，以便在编译时无法知道其值：

dart
void g(int i) {
  if (i == 0 || i > 4) {
    print('false');
  }
}

如果条件正确，则简化代码以不计算条件：

dart
void f() {
  print('true');
}

no_adjacent_strings_in_list

#

不要在列表字面量中使用相邻的字符串。

说明

#

当列表字面量中的两个字符串字面量相邻时，分析器会生成此诊断信息。在 Dart 中，相邻的字符串将连接在一起形成单个字符串，但意图可能是将每个字符串作为列表中的单独元素。

示例

#

以下代码会生成此诊断信息，因为字符串 'a' 和 'b' 相邻：

dart
List<String> list = ['a' 'b', 'c'];

常规修复

#

如果这两个字符串旨在成为列表的单独元素，则在它们之间添加逗号：

dart
List<String> list = ['a', 'b', 'c'];

如果这两个字符串旨在成为单个连接的字符串，则手动合并字符串：

dart
List<String> list = ['ab', 'c'];

或者使用 + 运算符连接字符串：

dart
List<String> list = ['a' + 'b', 'c'];

no_duplicate_case_values

#

case 子句的值 ('{0}') 等于前面 case 子句的值 ('{1}')。

说明

#

当同一 switch 语句中的两个或多个 case 子句具有相同的值时，分析器会生成此诊断信息。

任何第一个 case 子句之后的 case 子句都不能执行，所以具有重复的 case 子句具有误导性。

此诊断信息通常是由于拼写错误或常量值的变化造成的。

示例

#

以下代码会生成此诊断信息，因为两个 case 子句具有相同的值 (1)：

dart
// @dart = 2.14
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 1:
      break;
  }
}

常规修复

#

如果其中一个子句应具有不同的值，则更改子句的值：

dart
void f(int v) {
  switch (v) {
    case 1:
      break;
    case 2:
      break;
  }
}

如果该值正确，则将语句合并到单个子句中：

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

no_leading_underscores_for_library_prefixes

#

库前缀 '{0}' 以下划线开头。

说明

#

当导入上声明的前缀的名称以下划线开头时，分析器会生成此诊断信息。

库前缀在声明库之外本质上是不可见的，所以指示私有的前导下划线不会增加任何价值。

示例

#

以下代码会生成此诊断信息，因为前缀 _core 以下划线开头：

dart
import 'dart:core' as _core;

常规修复

#

删除下划线：

dart
import 'dart:core' as core;

no_leading_underscores_for_local_identifiers

#

局部变量 '{0}' 以下划线开头。

说明

#

当局部变量的名称以下划线开头时，分析器会生成此诊断信息。

局部变量在其声明的库之外本质上是不可见的，因此指示私有的前导下划线不会增加任何价值。

示例

#

以下代码会生成此诊断信息，因为参数 _s 以下划线开头：

dart
int f(String _s) => _s.length;

常规修复

#

删除下划线：

dart
int f(String s) => s.length;

no_logic_in_create_state

#

不要在 'createState' 中放置任何逻辑。

说明

#

当 StatefulWidget 的子类中的 createState 的实现包含除返回调用零参数构造函数的结果以外的任何逻辑时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数调用有参数：

dart
import 'package:flutter/material.dart';

class MyWidget extends StatefulWidget {
  @override
  MyState createState() => MyState(0);
}

class MyState extends State {
  int x;

  MyState(this.x);
}

常规修复

#

重写代码，使 createState 不包含任何逻辑：

dart
import 'package:flutter/material.dart';

class MyWidget extends StatefulWidget {
  @override
  MyState createState() => MyState();
}

class MyState extends State {
  int x = 0;

  MyState();
}

no_wildcard_variable_uses

#

引用的标识符是通配符。

说明

#

当参数或局部变量的名称仅由下划线组成时，分析器会生成此诊断信息。此类名称在未来版本的 Dart 语言中将变为非绑定，从而使引用非法。

示例

#

以下代码会生成此诊断信息，因为参数的名称由两个下划线组成：

dart
// @dart = 3.6
void f(int __) {
  print(__);
}

以下代码会生成此诊断信息，因为局部变量的名称由单个下划线组成：

dart
// @dart = 3.6
void f() {
  int _ = 0;
  print(_);
}

常规修复

#

如果打算引用变量或参数，则为其指定一个至少包含一个非下划线字符的名称：

dart
void f(int p) {
  print(p);
}

如果不需要引用变量或参数，则将引用替换为不同的表达式：

dart
void f() {
  print(0);
}

non_constant_identifier_names

#

变量名 '{0}' 不是 lowerCamelCase 标识符。

说明

#

当类成员、顶级声明、变量、参数、命名参数或未声明为 const 的命名构造函数的名称不使用 lowerCamelCase 约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级变量 Count 没有以小写字母开头：

dart
var Count = 0;

常规修复

#

更改声明中的名称以遵循 lowerCamelCase 约定：

dart
var count = 0;

null_check_on_nullable_type_parameter

#

不应在类型为潜在可空类型参数的变量上使用空检查运算符。

说明

#

当在类型为 T? 的变量上使用空检查运算符时，分析器会生成此诊断信息，其中 T 是一个类型参数，允许类型参数为空（没有边界或边界为空）。

给定一个具有可空边界的泛型类型参数 T ，在使用类型为 T? 的变量时，很容易引入错误的空检查。具体来说，拥有 T? x; 并想要断言 x 已被设置为类型 T 的有效值的情况并不少见。常见的错误是使用 x! 来做到这一点。这几乎总是不正确的，因为如果 T 是可空类型，则 x 可以有效地保存 null 作为类型 T 的值。

示例

#

以下代码会生成此诊断信息，因为 t 的类型为 T? ，而 T 允许类型参数为空（因为它没有 extends 子句）：

dart
T f<T>(T? t) => t!;

常规修复

#

使用类型参数强制转换变量：

dart
T f<T>(T? t) => t as T;

overridden_fields

#

字段覆盖从 '{0}' 继承的字段。

说明

#

当类定义覆盖超类中字段的字段时，分析器会生成此诊断信息。

用另一个字段覆盖字段会导致对象具有两个不同的字段，但由于字段具有相同的名称，因此只能在一个给定的作用域中引用其中一个字段。这可能会导致混淆，其中对其中一个字段的引用可能被误认为是对另一个字段的引用。

示例

#

以下代码会生成此诊断信息，因为 B 中的字段 f 遮蔽了 A 中的字段 f ：

dart
class A {
  int f = 1;
}

class B extends A {
  @override
  int f = 2;
}

常规修复

#

如果这两个字段表示相同的属性，则从子类中删除该字段：

dart
class A {
  int f = 1;
}

class B extends A {}

如果这两个字段应该不同，则重命名其中一个字段：

dart
class A {
  int f = 1;
}

class B extends A {
  int g = 2;
}

如果这两个字段以某种方式相关，但不能相同，则找到实现所需语义的不同方法。

package_names

#

包名 '{0}' 不是 lower_case_with_underscores 标识符。

说明

#

当包的名称未使用 lower_case_with_underscores 命名约定时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为包的名称使用 lowerCamelCase 命名约定：

yaml
name: somePackage

常规修复

#

使用 lower_case_with_underscores 命名约定重写包的名称：

yaml
name: some_package

package_prefixed_library_names

#

库名不是包名前缀的点分隔路径。

说明

#

当库的名称不遵循以下准则时，分析器会生成此诊断信息：

  • 将所有库名称名前缀加上包名称。
  • 使入口库的名称与包的名称相同。
  • 对于包中的所有其他库，在包名称后添加库的 Dart 文件的点分隔路径。
  • 对于 lib 下的库，省略顶级目录名称。

例如，给定一个名为 my_package 的包，以下是包中各种文件的库名称：

示例

#

假设包含以下代码的文件不在名为 special.dart 的文件中，该文件位于名为 something 的包的 lib 目录中（这将是该规则的例外），分析器会生成此诊断信息，因为库的名称不符合上述准则：

dart
library something.special;

常规修复

#

更改库的名称以符合准则。

prefer_adjacent_string_concatenation

#

字符串字面量不应通过 '+' 运算符连接。

说明

#

当使用 + 运算符连接两个字符串字面量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为两个字符串字面量正在使用 + 运算符连接：

dart
var s = 'a' + 'b';

常规修复

#

删除运算符：

dart
var s = 'a' 'b';

prefer_collection_literals

#

不必要的构造函数调用。

说明

#

当使用构造函数创建列表、映射或集合时，分析器会生成此诊断信息，但字面量会产生相同的结果。

示例

#

以下代码会生成此诊断信息，因为 Map 的构造函数用于创建也可以使用字面量创建的映射：

dart
var m = Map<String, String>();

常规修复

#

使用字面量表示：

dart
var m = <String, String>{};

prefer_conditional_assignment

#

'if' 语句可以用空感知赋值替换。

说明

#

当对变量的赋值基于变量的值是否为 null ，并且可以使用 ??= 运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为参数 s 正在与 null 进行比较，以确定是否要赋值不同的值：

dart
int f(String? s) {
  if (s == null) {
    s = '';
  }
  return s.length;
}

常规修复

#

使用 ??= 运算符代替显式的 if 语句：

dart
int f(String? s) {
  s ??= '';
  return s.length;
}

prefer_const_constructors

#

用 'const' 和构造函数来提高性能。

说明

#

当 const 构造函数的调用既没有 const 为前缀，也不在 常量上下文 中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 const 构造函数的调用既没有 const 为前缀，也不在 常量上下文 中：

dart
class C {
  const C();
}

C c = C();

常规修复

#

如果上下文可以成为 常量上下文 ，则这样做：

dart
class C {
  const C();
}

const C c = C();

如果上下文不能成为 常量上下文 ，则在构造函数调用前添加 const ：

dart
class C {
  const C();
}

C c = const C();

prefer_const_constructors_in_immutables

#

'@immutable' 类中的构造函数应声明为 'const'。

说明

#

当在具有 @immutable 注解的类中找到非 const 构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 中的构造函数没有声明为 const ，即使 C 有 @immutable 注解：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  C(this.f) ;
}

常规修复

#

如果该类确实旨在为不可变的，则向构造函数添加 const 修饰符：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

如果该类是可变的，则删除 @immutable 注解：

dart
class C {
  final f;

  C(this.f);
}

prefer_const_declarations

#

对初始化为常量值的 final 变量使用 'const'。

说明

#

当顶级变量、静态字段或局部变量被标记为 final 并初始化为常量值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级变量 v 既是 final ，又初始化为常量值：

dart
final v = const <int>[];

以下代码会生成此诊断信息，因为静态字段 f 既是 final ，又初始化为常量值：

dart
class C {
  static final f = const <int>[];
}

以下代码会生成此诊断信息，因为局部变量 v 既是 final ，又初始化为常量值：

dart
void f() {
  final v = const <int>[];
  print(v);
}

常规修复

#

将关键字 final 替换为 const 并从初始化器中删除 const ：

dart
class C {
  static const f = <int>[];
}

prefer_const_literals_to_create_immutables

#

使用 'const' 字面量作为 '@immutable' 类的构造函数的参数。

说明

#

当将非 const 列表、映射或集合字面量作为参数传递给用 @immutable 注释的类中声明的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为列表字面量

([1]) is being passed to a constructor in an immutable class but isn't a constant list:

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

C c = C([1]);

常规修复

#

如果上下文可以成为 常量上下文 ，则这样做：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

const C c = C([1]);

如果上下文不能成为 常量上下文 ，但可以使用 const 调用构造函数，则在构造函数调用之前添加 const ：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

C c = const C([1]);

如果上下文不能成为 常量上下文 ，并且不能使用 const 调用构造函数，则在集合字面量之前添加关键字 const ：

dart
import 'package:meta/meta.dart';

@immutable
class C {
  final f;

  const C(this.f);
}

C c = C(const [1]);

prefer_contains

#

始终为 'false'，因为 'indexOf' 始终大于或等于 -1。

始终为 'true'，因为 'indexOf' 始终大于或等于 -1。

不必要地使用 'indexOf' 来测试是否包含。

说明

#

当使用 indexOf 方法并且结果仅以语义等效于使用 contains 的方式与 -1 或 0 进行比较时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 if 语句中的条件正在检查列表是否包含该字符串：

dart
void f(List<String> l, String s) {
  if (l.indexOf(s) < 0) {
    // ...
  }
}

常规修复

#

使用 contains 代替，如有必要，否定条件：

dart
void f(List<String> l, String s) {
  if (l.contains(s)) {
    // ...
  }
}

prefer_double_quotes

#

不必要地使用单引号。

说明

#

当字符串字面量使用单引号 (') 而可以使用双引号 (")，并且不需要额外的转义符，并且不会影响可读性时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字符串字面量使用单引号，但没有必要：

dart
void f(String name) {
  print('Hello $name');
}

常规修复

#

用双引号代替单引号：

dart
void f(String name) {
  print("Hello $name");
}

prefer_final_fields

#

私有字段 {0} 可以是 'final'。

说明

#

当私有字段只赋值一次时，分析器会生成此诊断信息。该字段可以在多个构造函数中初始化，仍然会被标记，因为这些构造函数中只有一个可以运行。

示例

#

以下代码会生成此诊断信息，因为字段 _f 只赋值一次，在字段的初始化器中：

dart
class C {
  int _f = 1;

  int get f => _f;
}

常规修复

#

将字段标记为 final ：

dart
class C {
  final int _f = 1;

  int get f => _f;
}

prefer_for_elements_to_map_fromiterable

#

从可迭代对象构建映射时，使用 'for' 元素。

说明

#

当使用 Map.fromIterable 构建可以使用 for 元素构建的映射时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 fromIterable 用于构建可以使用 for 元素构建的映射：

dart
void f(Iterable<String> data) {
  Map<String, int>.fromIterable(
    data,
    key: (element) => element,
    value: (element) => element.length,
  );
}

常规修复

#

使用 for 元素构建映射：

dart
void f(Iterable<String> data) {
  <String, int>{
    for (var element in data)
      element: element.length
  };
}

prefer_function_declarations_over_variables

#

使用函数声明而不是变量赋值将函数绑定到名称。

说明

#

当闭包被赋值给局部变量，并且局部变量在任何地方都没有被重新赋值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为局部变量 f 被初始化为闭包，并且没有被赋值任何其他值：

dart
void g() {
  var f = (int i) => i * 2;
  f(1);
}

常规修复

#

将局部变量替换为局部函数：

dart
void g() {
  int f(int i) => i * 2;
  f(1);
}

prefer_generic_function_type_aliases

#

在 'typedef' 中使用泛型函数类型语法。

说明

#

当使用旧的函数类型别名语法编写 typedef 时，分析器会生成此诊断信息，在该语法中，声明的名称嵌入在函数类型中。

示例

#

以下代码会生成此诊断信息，因为它使用了旧的语法：

dart
typedef void F<T>();

常规修复

#

重写 typedef 以使用较新的语法：

dart
typedef F<T> = void Function();

prefer_if_null_operators

#

在测试 'null' 时，使用 '??' 运算符而不是 '?:'。

说明

#

当使用条件表达式（使用 ?: 运算符）在局部变量为 null 时选择不同的值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 s 正在与 null 进行比较，以便在 s 为 null 时返回不同的值：

dart
String f(String? s) => s == null ? '' : s;

常规修复

#

使用 if-null 运算符代替：

dart
String f(String? s) => s ?? '';

prefer_initializing_formals

#

使用初始化形式参数将参数赋值给字段。

说明

#

当构造函数参数用于初始化字段而无需修改时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为参数 c 仅用于设置字段 c ：

dart
class C {
  int c;

  C(int c) : this.c = c;
}

常规修复

#

使用初始化形式参数初始化字段：

dart
class C {
  int c;

  C(this.c);
}

prefer_inlined_adds

#

可以内联列表项的添加。

可以内联多个列表项的添加。

说明

#

当在列表字面量上调用 add 和 addAll 方法，并且可以将要添加的元素包含在列表字面量中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为正在使用 add 方法添加 b ，而它可以直接包含在列表字面量中：

dart
List<String> f(String a, String b) {
  return [a].. add(b) ;
}

以下代码会生成此诊断信息，因为正在使用 addAll 方法添加 b 的元素，而它可以直接包含在列表字面量中：

dart
List<String> f(String a, List<String> b) {
  return [a].. addAll(b) ;
}

常规修复

#

如果正在使用 add 方法，则使参数成为列表的元素并删除调用：

dart
List<String> f(String a, String b) {
  return [a, b];
}

如果正在使用 addAll 方法，则在参数上使用展开运算符将其元素添加到列表中并删除调用：

dart
List<String> f(String a, List<String> b) {
  return [a, ...b];
}

prefer_interpolation_to_compose_strings

#

使用插值来组合字符串和值。

说明

#

当使用 + 运算符连接字符串字面量和计算的字符串时，分析器会生成此诊断信息，但字符串插值将达到相同的结果。

示例

#

以下代码会生成此诊断信息，因为字符串#### 说明

当在实例方法之外使用关键字 super 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 super 用于顶级函数中：

dart
void f() {
  super.f();
}

常规修复

#

重写代码以不使用 super 。

super_in_redirecting_constructor

#

重定向构造函数不能有 'super' 初始化器。

说明

#

当重定向到另一个构造函数的构造函数也尝试调用超类的构造函数时，分析器会生成此诊断信息。当调用重定向构造函数重定向到的构造函数时，将调用超类构造函数。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 同时重定向到 C.b 并调用超类的构造函数：

dart
class C {
  C.a() : this.b(), super();
  C.b();
}

常规修复

#

删除 super 构造函数的调用：

dart
class C {
  C.a() : this.b();
  C.b();
}

switch_case_completes_normally

#

'case' 不应正常完成。

说明

#

当 switch 语句中 case 标签后的语句可能贯穿到下一个 case 或 default 标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值为零 (0) 的 case 标签贯穿到 default 语句：

dart
void f(int a) {
  switch (a) {
    case 0:
      print(0);
    default:
      return;
  }
}

常规修复

#

更改控制流，以便 case 不会贯穿。这可以通过在当前语句列表的末尾添加以下内容之一来完成：

  • 一个 return 语句，
  • 一个 throw 表达式，
  • 一个 break 语句，
  • 一个 continue ，或
  • 一个返回类型为 Never 的函数或方法的调用。

switch_expression_not_assignable

#

switch 表达式的类型 '{0}' 无法赋值给 case 表达式的类型 '{1}'。

说明

#

当 switch 语句中的表达式的类型无法赋值给 case 子句中表达式的类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 s 的类型（ String ）无法赋值给 0 的类型（ int ）：

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

常规修复

#

如果 case 表达式的类型正确，则更改 switch 语句中的表达式使其具有正确的类型：

dart
void f(String s) {
  switch (int.parse(s)) {
    case 0:
      break;
  }
}

如果 switch 表达式的类型正确，则更改 case 表达式使其具有正确的类型：

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

tearoff_of_generative_constructor_of_abstract_class

#

不能分离抽象类的生成式构造函数。

说明

#

当从抽象类中分离生成式构造函数时，分析器会生成此诊断信息。这是不允许的，因为实例化抽象类是无效的，这意味着分离的构造函数没有有效的用途。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.new 正在被分离，而类 C 是抽象类：

dart
abstract class C {
  C();
}

void f() {
  C.new;
}

常规修复

#

分离具体类的构造函数。

text_direction_code_point_in_comment

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

text_direction_code_point_in_literal

#

Unicode 代码点 'U+{0}' 会更改文本的外观，使其与编译器解释的方式不同。

说明

#

当遇到包含文本方向 Unicode 代码点的源代码时，分析器会生成此诊断信息。这些代码点会导致字符串字面量或注释中的源代码的解释和编译方式与在编辑器中显示的方式不同，从而导致可能的安全漏洞。

示例

#

以下代码会生成此诊断信息两次，因为标签字符串的开头和结尾处有隐藏字符：

dart
var label = 'Interactive text';

常规修复

#

如果打算在字符串字面量中包含代码点，则对其进行转义：

dart
var label = '\u202AInteractive text\u202C';

如果不打算在字符串字面量中包含代码点，则将其删除：

dart
var label = 'Interactive text';

throw_of_invalid_type

#

抛出表达式的类型 '{0}' 必须可赋值为 'Object'。

说明

#

当 throw 表达式中的表达式的类型无法赋值给 Object 时，分析器会生成此诊断信息。抛出 null 是无效的，因此使用可能计算为 null 的表达式也是无效的。

示例

#

以下代码会生成此诊断信息，因为 s 可能为 null ：

dart
void f(String? s) {
  throw s;
}

常规修复

#

向表达式添加显式的空检查：

dart
void f(String? s) {
  throw s!;
}

top_level_cycle

#

无法推断 '{0}' 的类型，因为它通过循环依赖自身：{1}。

说明

#

当顶级变量没有类型注解，并且变量的初始化器直接或间接引用该变量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为变量 x 和 y 是根据彼此定义的，并且两者都没有显式类型，因此无法推断另一个的类型：

dart
var x = y;
var y = x;

常规修复

#

如果这两个变量不需要相互引用，则打破循环：

dart
var x = 0;
var y = x;

如果这两个变量需要相互引用，则至少为其中一个变量提供显式类型：

dart
int x = y;
var y = x;

但是，请注意，虽然此代码不会生成任何诊断信息，但除非在循环中的任何变量被引用之前，至少为一个变量赋值一个不依赖于其他变量的值，否则它会在运行时产生堆栈溢出。

type_alias_cannot_reference_itself

#

typedef 不能直接或通过另一个 typedef 递归地引用自身。

说明

#

当 typedef 直接或间接引用自身时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 F 通过 G 间接依赖于自身：

dart
typedef F = void Function(G);
typedef G = void Function(F);

常规修复

#

更改循环中的一个或多个 typedef，使它们都不引用自身：

dart
typedef F = void Function(G);
typedef G = void Function(int);

type_annotation_deferred_class

#

延迟加载类型 '{0}' 不能用于声明、强制转换或类型测试中。

说明

#

当类型注解位于变量声明中，或者在强制转换 (as) 或类型测试 (is) 中使用的类型是在使用延迟导入导入的库中声明的类型时，分析器会生成此诊断信息。这些类型需要在编译时可用，但不可用。

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

示例

#

以下代码会生成此诊断信息，因为参数 f 的类型是从延迟加载库导入的：

dart
import 'dart:io' deferred as io;

void f(io.File f) {}

常规修复

#

如果您需要引用导入的类型，则删除 deferred 关键字：

dart
import 'dart:io' as io;

void f(io.File f) {}

如果需要延迟导入，并且还有其他合适的类型，则使用该类型代替延迟加载库中的类型。

type_argument_not_matching_bounds

#

' {0}' 不符合类型参数 '{1}' 的边界 '{2}'。

说明

#

当类型参数不是相同类型或其对应类型参数的子类时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 不是 num 的子类：

dart
class A<E extends num> {}

var a = A<String>();

常规修复

#

将类型参数更改为边界的子类：

dart
class A<E extends num> {}

var a = A<int>();

type_check_with_null

#

对非空的测试应使用 '!= null' 进行。

对 null 的测试应使用 '== null' 进行。

说明

#

当类型检查（使用 as 运算符）的类型为 Null 时，分析器会生成此诊断信息。只有一个值为 Null 类型，因此当显式测试 null 时，代码的可读性和性能都会更好。

示例

#

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为 null ：

dart
void f(String? s) {
  if (s is Null) {
    return;
  }
  print(s);
}

以下代码会生成此诊断信息，因为代码正在使用类型检查来测试 s 的值是否为非 null ：

dart
void f(String? s) {
  if (s is! Null) {
    print(s);
  }
}

常规修复

#

将类型检查替换为与 null 的等效比较：

dart
void f(String? s) {
  if (s == null) {
    return;
  }
  print(s);
}

type_parameter_referenced_by_static

#

静态成员不能引用类的类型参数。

说明

#

当静态成员引用为类声明的类型参数时，分析器会生成此诊断信息。类型参数仅对类的实例有意义。

示例

#

以下代码会生成此诊断信息，因为静态方法 hasType 引用了类型参数 T ：

dart
class C<T> {
  static bool hasType(Object o) => o is T;
}

常规修复

#

如果成员可以是实例成员，则删除关键字 static ：

dart
class C<T> {
  bool hasType(Object o) => o is T;
}

如果成员必须是静态成员，则使成员成为泛型：

dart
class C<T> {
  static bool hasType<S>(Object o) => o is S;
}

但是，请注意， T 和 S 之间没有关系，因此第二个选项会更改与可能预期的语义。

type_parameter_supertype_of_its_bound

#

' {0}' 不能是其上限的超类型。

说明

#

当类型参数的边界（ extends 关键字后的类型）直接或间接为类型参数本身时，分析器会生成此诊断信息。声明类型参数必须与自身相同是没有意义的。

示例

#

以下代码会生成此诊断信息，因为 T 的边界是 T ：

dart
class C<T extends T> {}

以下代码会生成此诊断信息，因为 T1 的边界是 T2 ，而 T2 的边界是 T1 ，有效地使 T1 的边界为 T1 ：

dart
class C<T1 extends T2, T2 extends T1> {}

常规修复

#

如果类型参数需要是某种类型的子类，则用所需的类型替换边界：

dart
class C<T extends num> {}

如果类型参数可以是任何类型，则删除 extends 子句：

dart
class C<T> {}

type_test_with_non_type

#

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

说明

#

当 is 或 is! 测试的右侧不是类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为右侧是参数，而不是类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is b) {
    return;
  }
}

常规修复

#

如果您打算使用类型测试，则将右侧替换为类型：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a is B) {
    return;
  }
}

如果您打算使用其他类型的测试，则更改测试：

dart
typedef B = int Function(int);

void f(Object a, B b) {
  if (a == b) {
    return;
  }
}

type_test_with_undefined_name

#

名称 '{0}' 未定义，因此不能在 'is' 表达式中使用。

说明

#

当类型测试表达式中的 is 后的名称未定义时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 Srting 未定义：

dart
void f(Object o) {
  if (o is Srting) {
    // ...
  }
}

常规修复

#

将名称替换为类型的名称：

dart
void f(Object o) {
  if (o is String) {
    // ...
  }
}

unchecked_use_of_nullable_value

#

可空表达式不能用作条件。

可空表达式不能用作 for-in 循环中的迭代器。

可空表达式不能用于展开中。

可空表达式不能用于 yield-each 语句中。

由于函数可能为 'null'，因此不能无条件调用该函数。

由于接收者可能为 'null'，因此不能无条件调用方法 '{0}'。

由于接收者可能为 'null'，因此不能无条件调用运算符 '{0}'。

由于接收者可能为 'null'，因此不能无条件访问属性 '{0}'。

说明

#

当在不首先验证值是否为 null 的情况下取消引用类型为 潜在的非空类型 的表达式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为在引用 s 时， s 可能为 null ：

dart
void f(String? s) {
  if (s.length > 3) {
    // ...
  }
}

常规修复

#

如果该值确实可以为 null ，则添加一个测试以确保只有在该值不为 null 时才访问成员：

dart
void f(String? s) {
  if (s != null && s.length > 3) {
    // ...
  }
}

如果该表达式是变量，并且该值绝不应为 null ，则将变量的类型更改为非空：

dart
void f(String s) {
  if (s.length > 3) {
    // ...
  }
}

如果您认为表达式的值绝不应为 null ，但您无法更改变量的类型，并且您愿意承担如果出错则在运行时抛出异常的风险，则可以断言该值不为 null：

dart
void f(String? s) {
  if (s!.length > 3) {
    // ...
  }
}

undefined_annotation

#

用作注解的未定义名称 '{0}'。

说明

#

当使用未定义的名称作为注解时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 undefined 未定义：

dart
@undefined
void f() {}

常规修复

#

如果名称正确，但尚未声明，则将其声明为常量值：

dart
const undefined = 'undefined';

@undefined
void f() {}

如果名称错误，则将名称替换为有效常量的名称：

dart
@deprecated
void f() {}

否则，删除注解。

undefined_class

#

未定义的类 '{0}'。

说明

#

当遇到看起来像是类的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 Piont 未定义：

dart
class Point {}

void f(Piont p) {}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的类的名称。可以通过修复类的拼写来更正上面的示例：

dart
class Point {}

void f(Point p) {}

如果已定义该类但不可见，则可能需要添加导入。

undefined_constructor_in_initializer

#

类 '{0}' 没有名为 '{1}' 的构造函数。

类 '{0}' 没有未命名的构造函数。

说明

#

当在构造函数的初始化器列表中调用超类构造函数，但超类没有定义正在调用的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 A 没有未命名的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super();
}

以下代码会生成此诊断信息，因为 A 没有名为 m 的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.m();
}

常规修复

#

如果超类定义了应调用的构造函数，则更改正在调用的构造函数：

dart
class A {
  A.n();
}
class B extends A {
  B() : super.n();
}

如果超类没有定义合适的构造函数，则定义正在调用的构造函数：

dart
class A {
  A.m();
  A.n();
}
class B extends A {
  B() : super.m();
}

undefined_enum_constant

#

'{1}' 中没有名为 '{0}' 的常量。

说明

#

当遇到看起来像是枚举值的名称的标识符，并且该名称在其被引用的作用域中未定义或不可见时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 E 没有定义名为 c 的常量：

dart
enum E {a, b}

var e = E.c;

常规修复

#

如果应定义该常量，则将其添加到枚举的声明中：

dart
enum E {a, b, c}

var e = E.c;

如果常量不应定义，则将名称更改为现有常量的名称：

dart
enum E {a, b}

var e = E.b;

undefined_enum_constructor

#

枚举没有名为 '{0}' 的构造函数。

枚举没有未命名的构造函数。

说明

#

当调用用于初始化枚举值的构造函数不存在时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为枚举值 c 由未命名的构造函数初始化，但在 E 中没有定义未命名的构造函数：

dart
enum E {
  c() ;

  const E.x();
}

以下代码会生成此诊断信息，因为枚举值 c 由名为 x 的构造函数初始化，但在 E 中没有定义名为 x 的构造函数：

dart
enum E {
  c. x() ;

  const E.y();
}

常规修复

#

如果枚举值由未命名的构造函数初始化，并且应使用命名构造函数之一，则添加构造函数的名称：

dart
enum E {
  c.x();

  const E.x();
}

如果枚举值由未命名的构造函数初始化，并且命名构造函数都不合适，则定义未命名的构造函数：

dart
enum E {
  c();

  const E();
}

如果枚举值由命名的构造函数初始化，并且现有的构造函数之一应已被使用，则更改正在调用的构造函数的名称（或者如果应使用未命名的构造函数，则将其删除）：

dart
enum E {
  c.y();

  const E();
  const E.y();
}

如果枚举值由命名的构造函数初始化，并且现有构造函数都不应使用，则定义一个具有所用名称的构造函数：

dart
enum E {
  c.x();

  const E.x();
}

undefined_extension_getter

#

扩展 '{1}' 没有定义 getter '{0}'。

说明

#

当使用扩展重写调用 getter，但指定的扩展没有定义该 getter 时，分析器会生成此诊断信息。当引用静态 getter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 getter：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 getter：

dart
extension E on String {}

var x = E.a;

常规修复

#

如果 getter 的名称不正确，则将其更改为现有 getter 的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').a;
}

如果 getter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String get a => 'a';
}

extension F on String {
  String get b => 'b';
}

void f() {
  F('c').b;
}

如果 getter 和扩展的名称都正确，但未定义 getter，则定义 getter：

dart
extension E on String {
  String get a => 'a';
  String get b => 'z';
}

extension F on String {
  String get b => 'b';
}

void f() {
  E('c').b;
}

undefined_extension_method

#

扩展 '{1}' 没有定义方法 '{0}'。

说明

#

当使用扩展重写调用方法，但指定的扩展没有定义该方法时，分析器会生成此诊断信息。当引用静态方法但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例方法：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c'). b() ;
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态方法：

dart
extension E on String {}

var x = E. a() ;

常规修复

#

如果方法的名称不正确，则将其更改为现有方法的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').a();
}

如果方法的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  String a() => 'a';
}

extension F on String {
  String b() => 'b';
}

void f() {
  F('c').b();
}

如果方法和扩展的名称都正确，但未定义该方法，则定义该方法：

dart
extension E on String {
  String a() => 'a';
  String b() => 'z';
}

extension F on String {
  String b() => 'b';
}

void f() {
  E('c').b();
}

undefined_extension_operator

#

扩展 '{1}' 没有定义运算符 '{0}'。

说明

#

当在特定扩展上调用运算符时，该扩展没有实现该运算符，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有定义运算符 * ：

dart
var x = E('') * 4;

extension E on String {}

常规修复

#

如果扩展预计要实现该运算符，则向扩展中添加运算符的实现：

dart
var x = E('') * 4;

extension E on String {
  int operator *(int multiplier) => length * multiplier;
}

如果运算符由不同的扩展定义，则将扩展的名称更改为定义运算符的扩展的名称。

如果运算符在扩展重写的参数上定义，则删除扩展重写：

dart
var x = '' * 4;

extension E on String {}

undefined_extension_setter

#

扩展 '{1}' 没有定义 setter '{0}'。

说明

#

当使用扩展重写调用 setter，但指定的扩展没有定义该 setter 时，分析器会生成此诊断信息。当引用静态 setter 但指定的扩展没有定义它时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 b 的实例 setter：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

以下代码会生成此诊断信息，因为扩展 E 没有声明名为 a 的静态 setter：

dart
extension E on String {}

void f() {
  E.a = 3;
}

常规修复

#

如果 setter 的名称不正确，则将其更改为现有 setter 的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').a = 'd';
}

如果 setter 的名称正确，但扩展的名称错误，则将扩展的名称更改为正确的名称：

dart
extension E on String {
  set a(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  F('c').b = 'd';
}

如果 setter 和扩展的名称都正确，但未定义 setter，则定义 setter：

dart
extension E on String {
  set a(String v) {}
  set b(String v) {}
}

extension F on String {
  set b(String v) {}
}

void f() {
  E('c').b = 'd';
}

undefined_function

#

函数 '{0}' 未定义。

说明

#

当遇到看起来像是函数的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 emty 未定义：

dart
List<int> empty() => [];

void main() {
  print(emty());
}

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的函数的名称。可以通过修复函数的拼写来更正上面的示例：

dart
List<int> empty() => [];

void main() {
  print(empty());
}

如果已定义该函数但不可见，则可能需要添加导入或重新排列代码以使该函数可见。

undefined_getter

#

getter '{0}' 未在 '{1}' 函数类型中定义。

getter '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是 getter 的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 String 没有名为 len 的成员：

dart
int f(String s) => s.len;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的 getter 的名称。可以通过修复 getter 的拼写来更正上面的示例：

dart
int f(String s) => s.length;

undefined_hidden_name

#

库 '{0}' 没有导出具有隐藏名称 '{1}' 的成员。

说明

#

当隐藏组合器包含未由导入的库定义的名称时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:math 没有定义名称 String ：

dart
import 'dart:math' hide String, max;

var x = min(0, 1);

常规修复

#

如果应隐藏不同的名称，则更正名称。否则，从列表中删除名称：

dart
import 'dart:math' hide max;

var x = min(0, 1);

undefined_identifier

#

未定义的名称 '{0}'。

说明

#

当遇到未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为名称 rihgt 未定义：

dart
int min(int left, int right) => left <= rihgt ? left : right;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的标识符。可以通过修复变量的拼写来更正上面的示例：

dart
int min(int left, int right) => left <= right ? left : right;

如果已定义标识符但不可见，则可能需要添加导入或重新排列代码以使标识符可见。

undefined_identifier_await

#

在未用 'async' 标记的函数体中未定义名称 'await'。

说明

#

当在方法或函数体中使用名称 await 但未声明，并且主体未用 async 关键字标记时，分析器会生成此诊断信息。名称 await 仅在异步函数中引入 await 表达式。

示例

#

以下代码会生成此诊断信息，因为名称 await 用于 f 的主体中，即使 f 的主体未用 async 关键字标记：

dart
void f(p) { await p; }

常规修复

#

向函数体添加关键字 async ：

dart
void f(p) async { await p; }

undefined_method

#

方法 '{0}' 未在 '{1}' 函数类型中定义。

方法 '{0}' 未在类型 '{1}' 中定义。

说明

#

当遇到看起来像是方法的名称但未定义或在其被引用的作用域中不可见的标识符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标识符 removeMiddle 未定义：

dart
int f(List<int> l) => l. removeMiddle() ;

常规修复

#

如果标识符未定义，则定义它或将其替换为已定义的方法的名称。可以通过修复方法的拼写来更正上面的示例：

dart
int f(List<int> l) => l.removeLast();

undefined_named_parameter

#

命名参数 '{0}' 未定义。

说明

#

当方法或函数调用具有命名参数，但正在调用的方法或函数没有定义具有相同名称的参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 没有声明名为 a 的命名参数：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

常规修复

#

如果参数名称键入错误，则将其替换为正确的名称。可以通过将 a 更改为 b 来修复上面的示例：

dart
class C {
  m({int? b}) {}
}

void f(C c) {
  c.m(b: 1);
}

如果子类添加了一个具有该名称的参数，则将接收者强制转换为子类：

dart
class C {
  m({int? b}) {}
}

class D extends C {
  m({int? a, int? b}) {}
}

void f(C c) {
  (c as D).m(a: 1);
}

如果应将参数添加到函数，则添加它：

dart
class C {
  m({int? a, int? b}) {}
}

void f(C c) {
  c.m(a: 1);
}

undefined_operator

#

运算符 '{0}' 未在类型 '{1}' 中定义。

说明

#

当#### 说明

当标记为 const 的构造函数重定向到未标记为 const 的构造函数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为构造函数 C.a 被标记为 const ，但重定向到构造函数 C.b ，而 C.b 不是 const 构造函数：

dart
class C {
  const C.a() : this. b() ;
  C.b();
}

常规修复

#

如果非常量构造函数可以标记为 const ，则将其标记为 const ：

dart
class C {
  const C.a() : this.b();
  const C.b();
}

如果非常量构造函数不能标记为 const ，则删除重定向或从重定向构造函数中删除 const ：

dart
class C {
  C.a() : this.b();
  C.b();
}

如果生成式构造函数是未命名的构造函数，并且没有参数传递给它，则可以删除超类调用。

non_generative_implicit_constructor

#

超类 '{0}' 的未命名构造函数（由 '{1}' 的默认构造函数调用）必须是生成式构造函数，但找到了工厂构造函数。

说明

#

当类具有隐式生成式构造函数，而超类具有显式未命名的工厂构造函数时，分析器会生成此诊断信息。子类中的隐式构造函数隐式调用超类中的未命名构造函数，但生成式构造函数只能调用另一个生成式构造函数，而不能调用工厂构造函数。

示例

#

以下代码会生成此诊断信息，因为 B 中的隐式构造函数调用 A 中的未命名构造函数，但 A 中的构造函数是工厂构造函数，而需要生成式构造函数：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B extends A {}

常规修复

#

如果超类中的未命名构造函数可以是生成式构造函数，则将其更改为生成式构造函数：

dart
class A {
  A();
  A.named();
}

class B extends A { }

如果未命名构造函数不能是生成式构造函数，并且超类中还有其他生成式构造函数，则显式调用其中一个：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B extends A {
  B() : super.named();
}

如果没有可以使用的生成式构造函数，并且不能添加任何生成式构造函数，则实现超类而不是扩展它：

dart
class A {
  factory A() => throw 0;
  A.named();
}

class B implements A {}

non_native_function_type_argument_to_pointer

#

无法调用 'asFunction'，因为指针的函数签名 '{0}' 不是有效的 C 函数签名。

说明

#

当在指向本机函数的指针上调用 asFunction 方法，但本机函数的签名不是有效的 C 函数签名时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为与指针 p 关联的函数签名（ FNative ）不是有效的 C 函数签名：

dart
import 'dart:ffi';

typedef FNative = int Function(int);
typedef F = int Function(int);

class C {
  void f(Pointer<NativeFunction<FNative>> p) {
    p.asFunction<F>();
  }
}

常规修复

#

使 NativeFunction 签名成为有效的 C 签名：

dart
import 'dart:ffi';

typedef FNative = Int8 Function(Int8);
typedef F = int Function(int);

class C {
  void f(Pointer<NativeFunction<FNative>> p) {
    p.asFunction<F>();
  }
}

non_positive_array_dimension

#

数组维度必须是正数。

说明

#

当 Array 注解中给定的维度小于或等于零 (0) 时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为提供了 -1 的数组维度：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array(-8)
  external Array<Uint8> a0;
}

常规修复

#

将维度更改为正整数：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

如果这是一个可变长度的内联数组，则将注解更改为 Array.variable() ：

dart
import 'dart:ffi';

final class MyStruct extends Struct {
  @Array.variable()
  external Array<Uint8> a0;
}

non_sized_type_argument

#

类型 '{1}' 不是 '{0}' 的有效类型参数。类型参数必须是本机整数、'Float'、'Double'、'Pointer' 或 'Struct'、'Union' 或 'AbiSpecificInteger' 的子类型。

说明

#

当 Array 类的类型参数不是有效类型之一时，分析器会生成此诊断信息：本机整数、 Float 、 Double 、 Pointer 或 Struct 、 Union 或 AbiSpecificInteger 的子类型。

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

示例

#

以下代码会生成此诊断信息，因为 Array 的类型参数是 Void ，而 Void 不是有效类型之一：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Void> a0;
}

常规修复

#

将类型参数更改为有效类型之一：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(8)
  external Array<Uint8> a0;
}

non_sync_factory

#

工厂体不能使用 'async'、'async*' 或 'sync*'。

说明

#

当工厂构造函数的体用 async 、 async* 或 sync* 标记时，分析器会生成此诊断信息。所有构造函数（包括工厂构造函数）都需要返回声明它们的类的实例，而不是 Future 、 Stream 或 Iterator 。

示例

#

以下代码会生成此诊断信息，因为工厂构造函数的体用 async 标记：

dart
class C {
  factory C() async {
    return C._();
  }
  C._();
}

常规修复

#

如果必须将成员声明为工厂构造函数，则删除主体之前的关键字：

dart
class C {
  factory C() {
    return C._();
  }
  C._();
}

如果成员必须返回除封闭类的实例以外的其他内容，则将成员设为静态方法：

dart
class C {
  static Future<C> m() async {
    return C._();
  }
  C._();
}

non_type_as_type_argument

#

名称 '{0}' 不是类型，因此不能用作类型参数。

说明

#

当不是类型的标识符用作类型参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 是变量，而不是类型：

dart
var x = 0;
List<x> xList = [];

常规修复

#

将类型参数更改为类型：

dart
var x = 0;
List<int> xList = [];

non_type_in_catch_clause

#

名称 '{0}' 不是类型，不能用于 on-catch 子句中。

说明

#

当 catch 子句中的 on 后的标识符被定义为非类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是函数，而不是类型：

dart
void f() {
  try {
    // ...
  } on f {
    // ...
  }
}

常规修复

#

将名称更改为应捕获的对象类型：

dart
void f() {
  try {
    // ...
  } on FormatException {
    // ...
  }
}

non_void_return_for_operator

#

运算符 []= 的返回类型必须是 'void'。

说明

#

当 []= 运算符的声明的返回类型不是 void 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 []= 运算符的声明的返回类型为 int ：

dart
class C {
  int operator []=(int index, int value) => 0;
}

常规修复

#

将返回类型更改为 void ：

dart
class C {
  void operator []=(int index, int value) => 0;
}

non_void_return_for_setter

#

setter 的返回类型必须是 'void' 或不存在。

说明

#

当 setter 的定义的返回类型不是 void 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 setter p 的返回类型为 int ：

dart
class C {
  int set p(int i) => 0;
}

常规修复

#

将返回类型更改为 void 或省略返回类型：

dart
class C {
  set p(int i) => 0;
}

not_assigned_potentially_non_nullable_local_variable

#

非空局部变量 '{0}' 必须在使用之前赋值。

说明

#

当引用局部变量并且具有以下所有特征时，分析器会生成此诊断信息：

  • 具有 潜在的非空类型 。
  • 没有初始化器。
  • 未标记为 late 。
  • 分析器无法根据 明确赋值 的规范证明在引用之前将为局部变量赋值。

示例

#

以下代码会生成此诊断信息，因为 x 不能具有 null 值，但在为其赋值之前就被引用了：

dart
String f() {
  int x;
  return x.toString();
}

以下代码会生成此诊断信息，因为对 x 的赋值可能不会执行，因此它可能具有 null 值：

dart
int g(bool b) {
  int x;
  if (b) {
    x = 1;
  }
  return x * 2;
}

以下代码会生成此诊断信息，因为分析器无法根据明确赋值分析证明 x 不会在未为其赋值的情况下被引用：

dart
int h(bool b) {
  int x;
  if (b) {
    x = 1;
  }
  if (b) {
    return x * 2;
  }
  return 0;
}

常规修复

#

如果 null 是有效值，则使变量可为空：

dart
String f() {
  int? x;
  return x!.toString();
}

如果 null 不是有效值，并且有合理的默认值，则添加初始化器：

dart
int g(bool b) {
  int x = 2;
  if (b) {
    x = 1;
  }
  return x * 2;
}

否则，确保在访问该值之前，在每条可能的代码路径上都为其赋值：

dart
int g(bool b) {
  int x;
  if (b) {
    x = 1;
  } else {
    x = 2;
  }
  return x * 2;
}

您也可以将变量标记为 late ，这将删除诊断信息，但如果在访问变量之前未为其赋值，则会导致在运行时抛出异常。只有在您确定变量将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
int h(bool b) {
  late int x;
  if (b) {
    x = 1;
  }
  if (b) {
    return x * 2;
  }
  return 0;
}

not_a_type

#

{0} 不是类型。

说明

#

当名称用作类型但被声明为非类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 是函数：

dart
f() {}
g(f v) {}

常规修复

#

将名称替换为类型的名称。

not_binary_operator

#

' {0}' 不是二元运算符。

说明

#

当只能用作一元运算符的运算符用作二元运算符时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为运算符 ~ 只能用作一元运算符：

dart
var a = 5 ~ 3;

常规修复

#

将运算符替换为正确的二元运算符：

dart
var a = 5 - 3;

not_enough_positional_arguments

#

' {0}' 预期有 1 个位置参数，但找到 0 个。

预期有 1 个位置参数，但找到 0 个。

' {2}' 预期有 {0} 个位置参数，但找到 {1} 个。

{0} 个位置参数预期，但找到 {1} 个。

说明

#

当方法或函数调用的位置参数少于必需位置参数的数量时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 声明了两个必需参数，但只提供了一个参数：

dart
void f(int a, int b) {}
void g() {
  f(0);
}

常规修复

#

添加与其余参数对应的参数：

dart
void f(int a, int b) {}
void g() {
  f(0, 1);
}

not_initialized_non_nullable_instance_field

#

非空实例字段 '{0}' 必须初始化。

说明

#

当声明字段并具有以下所有特征时，分析器会生成此诊断信息：

示例

#

以下代码会生成此诊断信息，因为 x 在不允许为 null 时隐式初始化为 null ：

dart
class C {
  int x;
}

类似地，以下代码会生成此诊断信息，因为 x 在不允许为 null 时被其中一个构造函数隐式初始化为 null ，即使它由其他构造函数初始化：

dart
class C {
  int x;

  C(this.x);

  C.n();
}

常规修复

#

如果所有实例的字段都有合理的默认值，则添加初始化表达式：

dart
class C {
  int x = 0;
}

如果在创建实例时应提供字段的值，则添加一个设置字段值的构造函数或更新现有构造函数：

dart
class C {
  int x;

  C(this.x);
}

您还可以将字段标记为 late ，这将删除诊断信息，但如果在访问字段之前未为其赋值，则会导致在运行时抛出异常。只有在您确定字段在引用之前将始终被赋值时，才应使用此方法，即使分析器无法根据明确赋值分析证明这一点也是如此。

dart
class C {
  late int x;
}

not_initialized_non_nullable_variable

#

非空变量 '{0}' 必须初始化。

说明

#

当静态字段或顶级变量具有非空类型并且没有初始化器时，分析器会生成此诊断信息。通常，没有初始化器的字段和变量被初始化为 null ，但字段或变量的类型不允许将其设置为 null ，因此必须提供显式初始化器。

示例

#

以下代码会生成此诊断信息，因为字段 f 不能初始化为 null ：

dart
class C {
  static int f;
}

类似地，以下代码会生成此诊断信息，因为顶级变量 v 不能初始化为 null ：

dart
int v;

常规修复

#

如果字段或变量不能初始化为 null ，则添加一个将其设置为非空值的初始化器：

dart
class C {
  static int f = 0;
}

如果字段或变量应初始化为 null ，则将类型更改为可为空：

dart
int? v;

如果字段或变量不能在声明中初始化，但在引用之前将始终初始化，则将其标记为 late ：

dart
class C {
  static late int f;
}

not_iterable_spread

#

列表或集合字面量中的展开元素必须实现 'Iterable'。

说明

#

当出现在列表字面量或集合字面量中的展开元素的表达式的静态类型没有实现类型 Iterable 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m};

常规修复

#

最常见的修复方法是用产生可迭代对象的表达式替换该表达式：

dart
var m = <String, int>{'a': 0, 'b': 1};
var s = <String>{...m.keys};

not_map_spread

#

映射字面量中的展开元素必须实现 'Map'。

说明

#

当出现在映射字面量中的展开元素的表达式的静态类型没有实现类型 Map 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 l 不是 Map ：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l};

常规修复

#

最常见的修复方法是用产生映射的表达式替换该表达式：

dart
var l =  <String>['a', 'b'];
var m = <int, String>{...l.asMap()};

no_annotation_constructor_arguments

#

注解创建必须有参数。

说明

#

当注解由单个标识符组成，但该标识符是类的名称而不是变量的名称时，分析器会生成此诊断信息。要创建类的实例，标识符后必须跟一个参数列表。

示例

#

以下代码会生成此诊断信息，因为 C 是一个类，并且如果没有从类中调用 const 构造函数，则不能将类用作注解：

dart
class C {
  const C();
}

@C
var x;

常规修复

#

添加缺少的参数列表：

dart
class C {
  const C();
}

@C()
var x;

no_combined_super_signature

#

无法从被覆盖的方法推断 '{0}' 中缺少的类型：{1}。

说明

#

当存在需要推断一个或多个类型的函数声明，并且由于没有被覆盖的方法的函数类型是所有其他被覆盖方法的超类型（如 覆盖推断 所指定）时，无法推断这些类型，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 C 中声明的方法 m 缺少返回类型和参数 a 的类型，并且无法为其推断任何缺少的类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  m(a) ;
}

在此示例中，无法执行覆盖推断，因为被覆盖的方法在以下方面不兼容：

  • 参数类型（ String 和 int ）都不是对方的超类型。
  • 返回类型都不是对方的子类型。

常规修复

#

如果可能，向子类中与所有被覆盖方法的类型一致的方法添加类型：

dart
abstract class A {
  A m(String a);
}

abstract class B {
  B m(int a);
}

abstract class C implements A, B {
  C m(Object a);
}

no_generative_constructors_in_superclass

#

_类 '{0}' 不能扩展 '{1}'，因为 '{1}' 只有工厂构造函数（没有生成式构造函数），而

说明

#

当类型检查（使用 is 或 is! ）的值在编译时已知时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为测试 a is Object? 始终为 true ：

dart
bool f<T>(T a) => a is Object?;

常规修复

#

如果类型检查没有检查您想要检查的内容，则更改测试：

dart
bool f<T>(T a) => a is Object;

如果类型检查确实检查了您想要检查的内容，则将类型检查替换为其已知值或将其完全删除：

dart
bool f<T>(T a) => true;

unqualified_reference_to_non_local_static_member

#

超类型中的静态 {1} '{0}' 必须由定义类型的名称限定。

说明

#

当一个类中的代码引用超类中的静态成员，而没有在成员名称前加上超类的名称时，分析器会生成此诊断信息。静态成员只能在其声明的类中无前缀地引用。

示例

#

以下代码会生成此诊断信息，因为静态字段 x 在 getter g 中被引用，而没有在它前面加上定义类的名称：

dart
class A {
  static int x = 3;
}

class B extends A {
  int get g => x;
}

常规修复

#

在静态成员的名称前加上声明类的名称：

dart
class A {
  static int x = 3;
}

class B extends A {
  int get g => A.x;
}

unqualified_reference_to_static_member_of_extended_type

#

扩展类型或其超类之一中的静态成员必须由定义类型的名称限定。

说明

#

当找到未定义的名称，并且该名称与扩展类型或其超类之一的静态成员相同时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 m 是扩展类型 C 的静态成员：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    m() ;
  }
}

常规修复

#

如果您尝试引用在扩展之外声明的静态成员，则在对成员的引用之前添加类或扩展的名称：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    C.m();
  }
}

如果您正在引用尚未声明的成员，请添加声明：

dart
class C {
  static void m() {}
}

extension E on C {
  void f() {
    m();
  }

  void m() {}
}

unreachable_switch_case

#

此 case 被前面的 cases 覆盖。

说明

#

当 switch 语句中的 case 子句由于所有可匹配的值都被前面 case 子句匹配而无法匹配任何内容时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值 1 在前面的 case 中已匹配：

dart
void f(int x) {
  switch (x) {
    case 1:
      print('one');
    case 1:
      print('two');
  }
}

常规修复

#

更改一个或两个冲突的 cases 以匹配不同的值：

dart
void f(int x) {
  switch (x) {
    case 1:
      print('one');
    case 2:
      print('two');
  }
}

unreachable_switch_default

#

此 default 子句被前面的 cases 覆盖。

说明

#

当 switch 语句中的 default 子句由于所有可匹配的值都被前面 case 子句匹配而无法匹配任何内容时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为值 E.e1 和 E.e2 在前面的 cases 中已匹配：

dart
enum E { e1, e2 }

void f(E x) {
  switch (x) {
    case E.e1:
      print('one');
    case E.e2:
      print('two');
    default:
      print('other');
  }
}

常规修复

#

删除不必要的 default 子句：

dart
enum E { e1, e2 }
void f(E x) {
  switch (x) {
    case E.e1:
      print('one');
    case E.e2:
      print('two');
  }
}

unused_catch_clause

#

异常变量 '{0}' 未使用，因此可以删除 'catch' 子句。

说明

#

当找到 catch 子句，并且 catch 块中既未使用异常参数也未使用可选堆栈跟踪参数时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 e 未被引用：

dart
void f() {
  try {
    int.parse(';');
  } on FormatException catch (e) {
    // ignored
  }
}

常规修复

#

删除未使用的 catch 子句：

dart
void f() {
  try {
    int.parse(';');
  } on FormatException {
    // ignored
  }
}

unused_catch_stack

#

堆栈跟踪变量 '{0}' 未使用，可以删除。

说明

#

当 catch 子句中的堆栈跟踪参数未在 catch 块的主体中引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 stackTrace 未被引用：

dart
void f() {
  try {
    // ...
  } catch (exception, stackTrace) {
    // ...
  }
}

常规修复

#

如果您需要引用堆栈跟踪参数，则添加对它的引用。否则，将其删除：

dart
void f() {
  try {
    // ...
  } catch (exception) {
    // ...
  }
}

unused_element

#

声明 '{0}' 未被引用。

说明

#

当私有声明在其包含声明的库中未被引用时，分析器会生成此诊断信息。将分析以下类型的声明：

  • 私有的顶级声明及其所有成员
  • 公共声明的私有成员

并非对元素的所有引用都会将其标记为“已使用”：

  • 将值赋值给顶级变量（使用标准 = 赋值或空感知 ??= 赋值）不计为使用它。
  • 在文档注释引用中引用元素不计为使用它。
  • 在 is 表达式的右侧引用类、mixin 或枚举不计为使用它。

示例

#

假设库中的任何代码都没有引用 _C ，则以下代码会生成此诊断信息：

dart
class _C {}

常规修复

#

如果不需要声明，则将其删除。

如果打算使用声明，则添加使用它的代码。

unused_element_parameter

#

从不为可选参数 '{0}' 提供值。

说明

#

当从不为私有声明中声明的可选参数传递值时，分析器会生成此诊断信息。

示例

#

假设库中的任何代码都没有在任何 _m 的调用中为 y 传递值，则以下代码会生成此诊断信息：

dart
class C {
  void _m(int x, [int? y]) {}

  void n() => _m(0);
}

常规修复

#

如果不需要声明，则将其删除：

dart
class C {
  void _m(int x) {}

  void n() => _m(0);
}

如果打算使用声明，则添加使用它的代码。

unused_field

#

字段 '{0}' 的值未使用。

说明

#

当声明私有字段但从未读取它时，即使在一个或多个地方写入它，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为字段 _originalValue 在库中任何地方都没有被读取：

dart
class C {
  final String _originalValue;
  final String _currentValue;

  C(this._originalValue) : _currentValue = _originalValue;

  String get value => _currentValue;
}

它可能看起来像字段 _originalValue 在初始化器 (_currentValue = _originalValue) 中被读取，但这实际上是在引用同名参数，而不是引用该字段。

常规修复

#

如果不需要该字段，则将其删除。

如果打算使用该字段，则添加缺少的代码。

unused_import

#

未使用的导入：'{0}'。

说明

#

当导入不需要，因为导入的名称均未在导入库中引用时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 dart:async 中定义的任何内容在库中都没有被引用：

dart
import 'dart:async';

void main() {}

常规修复

#

如果不需要导入，则将其删除。

如果打算使用某些导入的名称，则添加缺少的代码。

unused_label

#

标签 '{0}' 未使用。

说明

#

当找到未使用的标签时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为标签 loop 在方法中任何地方都没有被引用：

dart
void f(int limit) {
  loop: for (int i = 0; i < limit; i++) {
    print(i);
  }
}

常规修复

#

如果不需要标签，则将其删除：

dart
void f(int limit) {
  for (int i = 0; i < limit; i++) {
    print(i);
  }
}

如果需要标签，则使用它：

dart
void f(int limit) {
  loop: for (int i = 0; i < limit; i++) {
    print(i);
    if (i != 0) {
      break loop;
    }
  }
}

unused_local_variable

#

局部变量 '{0}' 的值未使用。

说明

#

当声明局部变量但从未读取它时，即使在一个或多个地方写入它，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为从未读取 count 的值：

dart
void main() {
  int count = 0;
}

常规修复

#

如果不需要该变量，则将其删除。

如果打算使用该变量，则添加缺少的代码。

unused_result

#

' {0}' 应使用。{1}。

' {0}' 的值应使用。

说明

#

当调用用 useResult 注解注释的函数，并且未使用该函数返回的值时，分析器会生成此诊断信息。如果调用的值，如果该值传递给另一个函数，或者如果该值被赋值给变量或字段，则该值被认为是使用的。

示例

#

以下代码会生成此诊断信息，因为 c.a() 的调用未使用，即使方法 a 用 useResult 注解注释：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  c. a() ;
}

常规修复

#

如果您打算调用带注解的函数，则使用返回的值：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  print(c.a());
}

如果您打算调用不同的函数，则更正正在调用的函数的名称：

dart
import 'package:meta/meta.dart';

class C {
  @useResult
  int a() => 0;

  int b() => 0;
}

void f(C c) {
  c.b();
}

unused_shown_name

#

显示了名称 {0}，但未使用。

说明

#

当显示组合器包含未在库中使用的名称时，分析器会生成此诊断信息。因为它没有被引用，所以可以删除该名称。

示例

#

以下代码会生成此诊断信息，因为函数 max 未使用：

dart
import 'dart:math' show min, max;

var x = min(0, 1);

常规修复

#

使用该名称或将其删除：

dart
import 'dart:math' show min;

var x = min(0, 1);

uri_does_not_exist

#

URI 的目标不存在：'{0}'。

说明

#

当找到导入、导出或部分指令，并且 URI 引用不存在的文件时，分析器会生成此诊断信息。

示例

#

如果文件 lib.dart 不存在，则以下代码会生成此诊断信息：

dart
import 'lib.dart';

常规修复

#

如果 URI 键入错误或无效，则更正 URI。

如果 URI 正确，则创建该文件。

uri_does_not_exist_in_doc_import

#

URI 的目标不存在：'{0}'。

说明

#

当找到文档导入，并且 URI 引用不存在的文件时，分析器会生成此诊断信息。

示例

#

如果文件 lib.dart 不存在，则以下代码会生成此诊断信息：

dart
/// @docImport 'lib.dart';
library;

常规修复

#

如果 URI 键入错误或无效，则更正 URI。

如果 URI 正确，则创建该文件。

uri_has_not_been_generated

#

URI 的目标尚未生成：'{0}'。

说明

#

当找到导入、导出或部分指令，并且 URI 引用不存在的文件，并且文件名以代码生成器通常生成的模式结尾（例如以下模式之一）时，分析器会生成此诊断信息：

  • .g.dart
  • .pb.dart
  • .pbenum.dart
  • .pbserver.dart
  • .pbjson.dart
  • .template.dart

示例

#

如果文件 lib.g.dart 不存在，则以下代码会生成此诊断信息：

dart
import 'lib.g.dart';

常规修复

#

如果该文件是生成的文件，则运行生成该文件的生成器。

如果该文件不是生成的文件，则检查 URI 的拼写或创建该文件。

uri_with_interpolation

#

URI 不能使用字符串插值。

说明

#

当 import 、 export 或 part 指令中的字符串字面量包含插值时，分析器会生成此诊断信息。指令中 URI 的解析必须在声明编译之前发生，因此在确定 URI 的值时不能计算表达式。

示例

#

以下代码会生成此诊断信息，因为 import 指令中的字符串包含插值：

dart
import 'dart:$m';

const m = 'math';

常规修复

#

从 URI 中删除插值：

dart
import 'dart:math';

var zero = min(0, 0);

use_of_native_extension

#

Dart 本机扩展已弃用，在 Dart 2.15 中不可用。

说明

#

当使用 dart-ext 方案导入库时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为本机库 x 使用 dart-ext 方案导入：

dart
import 'dart-ext:x';

常规修复

#

重写代码以使用 dart:ffi 作为调用本机库内容的一种方式。

use_of_void_result

#

此表达式的类型为 'void'，因此其值不能使用。

说明

#

当分析器找到类型为 void 的表达式，并且该表达式在需要值的地方使用时（例如，在成员访问之前或赋值的右侧），分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 f 没有生成可以调用 toString 的对象：

dart
void f() {}

void g() {
  f().toString();
}

常规修复

#

重写代码使表达式具有值，或重写代码使其不依赖于该值。

values_declaration_in_enum

#

不能在枚举中声明名为 'values' 的成员。

说明

#

当枚举声明定义名为 values 的成员时，分析器会生成此诊断信息，无论该成员是枚举值、实例成员还是静态成员。

任何此类成员都会与返回包含所有枚举常量的列表的隐式声明的静态 getter values 冲突。

示例

#

以下代码会生成此诊断信息，因为枚举 E 定义了一个名为 values 的实例成员：

dart
enum E {
  v;
  void values() {}
}

常规修复

#

更改冲突成员的名称：

dart
enum E {
  v;
  void getValues() {}
}

variable_length_array_not_last

#

可变长度 'Array' 只能作为 Struct 的最后一个字段出现。

说明

#

当可变长度内联 Array 不是 Struct 的最后一个成员时，分析器会生成此诊断信息。

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

示例

#

以下代码会生成此诊断信息，因为字段 a0 的类型有三个嵌套数组，但在 Array 注解中只给出了两个维度：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array.variable()
  external Array<Uint8> a0;

  @Uint8()
  external int a1;
}

常规修复

#

将可变长度内联 Array 移动到结构体的最后一个字段。

dart
import 'dart:ffi';

final class C extends Struct {
  @Uint8()
  external int a1;

  @Array.variable()
  external Array<Uint8> a0;
}

如果内联数组具有固定大小，则使用大小对其进行注释：

dart
import 'dart:ffi';

final class C extends Struct {
  @Array(10)
  external Array<Uint8> a0;

  @Uint8()
  external int a1;
}

variable_pattern_keyword_in_declaration_context

#

声明上下文中的变量模式不能指定 'var' 或 'final' 关键字。

说明

#

当在声明上下文中使用变量模式时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为记录模式中的变量模式位于声明上下文中：

dart
void f((int, int) r) {
  var (var x, y) = r;
  print(x + y);
}

常规修复

#

删除变量模式中的 var 或 final 关键字：

dart
void f((int, int) r) {
  var (x, y) = r;
  print(x + y);
}

variable_type_mismatch

#

类型为 '{0}' 的值无法赋值给类型为 '{1}' 的 const 变量。

说明

#

当常量表达式的计算结果为 CastException 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 x 的值为 int ，它无法赋值给 y ，因为 int 不是 String ：

dart
const dynamic x = 0;
const String y = x;

常规修复

#

如果常量的声明正确，则更改正在赋值的值使其具有正确的类型：

dart
const dynamic x = 0;
const String y = '$x';

如果赋值的值正确，则更改声明使其具有正确的类型：

dart
const int x = 0;
const int y = x;

workspace_field_not_list

#

'workspace' 字段的值必须是相对文件路径的列表。

说明

#

当 workspace 键的值不是列表时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为顶级 workspace 键的值是字符串，而预期的是列表：

yaml
name: example
workspace: notPaths

常规修复

#

更改 workspace 字段的值，使其成为列表：

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

workspace_value_not_string

#

Workspace 条目必须是目录路径（字符串）。

说明

#

当 workspace 列表包含不是字符串的值时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 workspace 列表包含一个映射：

yaml
name: example
workspace:
    - image.gif: true

常规修复

#

更改 workspace 列表，使其只包含有效的 POSIX 样式目录路径：

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

workspace_value_not_subdirectory

#

Workspace 值必须是 '{0}' 的子目录的相对路径。

说明

#

当 workspace 列表包含的值不是包含 pubspec.yaml 文件的目录的子目录的相对路径时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 workspace 列表中的值不是包含 'pubspec.yaml' 文件的目录的子目录的相对路径：

yaml
name: example
workspace:
    - /home/my_package

常规修复

#

更改 workspace 列表，使其只包含子目录路径。

yaml
name: example
workspace:
    - pkg/package_1
    - pkg/package_2

wrong_number_of_parameters_for_operator

#

运算符 '-' 应声明 0 个或 1 个参数，但找到 {0} 个。

运算符 '{0}' 应声明 {1} 个参数，但找到 {2} 个。

说明

#

当运算符的声明的参数数量错误时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为运算符 + 必须有一个与右操作数对应的参数：

dart
class C {
  int operator +(a, b) => 0;
}

常规修复

#

添加或删除参数以匹配所需的数量：

dart
class C {
  int operator +(a) => 0;
}

wrong_number_of_parameters_for_setter

#

setter 必须声明恰好一个必需的位置参数。

说明

#

当找到没有声明恰好一个必需位置参数的 setter 时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 setter s 声明了两个必需的参数：

dart
class C {
  set s(int x, int y) {}
}

以下代码会生成此诊断信息，因为 setter s 声明了一个可选参数：

dart
class C {
  set s([int? x]) {}
}

常规修复

#

更改声明，使其恰好有一个必需的位置参数：

dart
class C {
  set s(int x) {}
}

wrong_number_of_type_arguments

#

类型 '{0}' 用 {1} 个类型参数声明，但给出 {2} 个类型参数。

说明

#

当使用具有类型参数的类型并提供类型参数，但类型参数的数量与类型参数的数量不同时，分析器会生成此诊断信息。

当调用构造函数，并且类型参数的数量与为类声明的类型参数的数量不匹配时，分析器也会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 C 有一个类型参数，但在将其用作类型注解时提供了两个类型参数：

dart
class C<E> {}

void f(C<int, int> x) {}

以下代码会生成此诊断信息，因为 C 声明了一个类型参数，但在创建实例时提供了两个类型参数：

dart
class C<E> {}

var c = C<int, int>() ;

常规修复

#

根据需要添加或删除类型参数，以匹配为类型定义的类型参数的数量：

dart
class C<E> {}

void f(C<int> x) {}

wrong_number_of_type_arguments_constructor

#

构造函数 '{0}.{1}' 没有类型参数。

说明

#

当在命名构造函数的名称后提供类型参数时，分析器会生成此诊断信息。构造函数不能声明类型参数，因此调用只能提供与类关联的类型参数，并且这些类型参数需要跟在类的名称后面而不是构造函数的名称后面。

示例

#

以下代码会生成此诊断信息，因为类型参数（ <String> ）位于构造函数的名称后面而不是类的名称后面：

dart
class C<T> {
  C.named();
}
C f() => C.named <String>() ;

常规修复

#

如果类型参数是类的类型参数，则将类型参数移动到类名称之后：

dart
class C<T> {
  C.named();
}
C f() => C<String>.named();

如果类型参数不是类的类型参数，则将其删除：

dart
class C<T> {
  C.named();
}
C f() => C.named();

yield_in_non_generator

#

yield 语句必须位于生成器函数中（用 'async*' 或 'sync*' 标记的函数）。

yield-each 语句必须位于生成器函数中（用 'async*' 或 'sync*' 标记的函数）。

说明

#

当 yield 或 yield* 语句出现在其主体未用 async* 或 sync* 修饰符标记的函数中时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 yield 用于主体没有修饰符的函数中：

dart
Iterable<int> get digits {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

以下代码会生成此诊断信息，因为 yield* 用于主体具有 async 修饰符而不是 async* 修饰符的函数中：

dart
Stream<int> get digits async {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

常规修复

#

添加修饰符，或将现有修饰符更改为 async* 或 sync* ：

dart
Iterable<int> get digits sync* {
  yield* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
}

yield_of_invalid_type

#

类型为 '{0}' 的 yield 值必须可赋值为 '{1}'。

由 'yield*' 表达式隐含的类型 '{0}' 必须可赋值为 '{1}'。

说明

#

当 yield 或 yield* 表达式产生的对象的类型与从生成器（用 sync* 或 async* 标记的函数或方法）返回的 Iterable 或 Stream 类型要返回的对象的类型不匹配时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 getter zero 声明为返回一个返回整数的 Iterable ，但 yield 从可迭代对象中返回一个字符串：

dart
Iterable<int> get zero sync* {
  yield '0';
}

常规修复

#

如果函数的返回类型正确，则修复 yield 关键字后的表达式以返回正确的类型：

dart
Iterable<int> get zero sync* {
  yield 0;
}

如果 yield 后的表达式正确，则更改函数的返回类型以允许它：

dart
Iterable<String> get zero sync* {
  yield '0';
}

always_declare_return_types

#

函数 '{0}' 应具有返回类型，但没有。

方法 '{0}' 应具有返回类型，但没有。

说明

#

当方法或函数没有显式返回类型时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为函数 f 没有返回类型：

dart
f() {}

常规修复

#

添加显式返回类型：

dart
void f() {}

always_put_control_body_on_new_line

#

语句应在单独的行上。

说明

#

当控制流语句 (if 、 for 、 while 或 do) 控制的代码与控制流语句位于同一行时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 return 语句与控制是否执行 return 的 if 位于同一行：

dart
void f(bool b) {
  if (b) return;
}

常规修复

#

将受控语句放在单独的缩进行上：

dart
void f(bool b) {
  if (b)
    return;
}

always_put_required_named_parameters_first

#

必需的命名参数应位于可选命名参数之前。

说明

#

当必需的命名参数出现在可选命名参数之后时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为必需的参数 x 在可选参数 y 之后：

dart
void f({int? y, required int x}) {}

常规修复

#

重新排序参数，以便所有必需的命名参数都位于任何可选命名参数之前：

dart
void f({required int x, int? y}) {}

always_use_package_imports

#

对 'lib' 目录中的文件使用 'package:' 导入。

说明

#

当 lib 目录内的库中的 import 使用相对路径导入同一包的 lib 目录内的另一个库时，分析器会生成此诊断信息。

示例

#

假设名为 a.dart 的文件和下面的代码都在同一包的 lib 目录内，则以下代码会生成此诊断信息，因为它使用了相对 URI 来导入 a.dart ：

dart
import 'a.dart';

常规修复

#

使用包导入：

dart
import 'package:p/a.dart';

annotate_overrides

#

成员 '{0}' 覆盖了继承的成员，但没有用 '@override' 注释。

说明

#

当成员覆盖继承的成员，但没有用 @override 注释时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为类 B 中的方法 m 覆盖了类 A 中同名的方法，但没有标记为有意的覆盖：

dart
class A {
  void m() {}
}

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

常规修复

#

如果子类中的成员旨在覆盖超类中的成员，则添加 @override 注解：

dart
class A {
  void m() {}
}

class B extends A {
  @override
  void m() {}
}

如果子类中的成员不旨在覆盖超类中的成员，则重命名其中一个成员：

dart
class A {
  void m() {}
}

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

avoid_empty_else

#

在 'else' 子句中不允许使用空语句。

说明

#

当 else 后的语句为空语句（分号）时，分析器会生成此诊断信息。

更多信息，请参见 avoid_empty_else 的文档。

示例

#

以下代码会生成此诊断信息，因为 else 后的语句为空语句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  else ;
    print("2");
}

常规修复

#

如果 else 后的语句旨在仅在条件为 false 时执行，则删除空语句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  else
    print("2");
}

如果没有代码旨在仅在条件为 false 时执行，则删除整个 else 子句：

dart
void f(int x, int y) {
  if (x > y)
    print("1");
  print("2");
}

avoid_function_literals_in_foreach_calls

#

不应将函数字面量传递给 'forEach'。

说明

#

当 Iterable.forEach 的参数是闭包时，分析器会生成此诊断信息。

示例

#

以下代码会生成此诊断信息，因为 forEach 的调用的参数是闭包：

dart
void f(Iterable<String> s) {
  s. forEach((e) => print(e));
}

常规修复

#

如果闭包可以用分离来替换，则替换闭包：

dart
void f(Iterable<String> s) {
  s.forEach(print);
}

如果闭包不能用分离来替换，则使用 for 循环来迭代元素：

dart
void f(Iterable<String> s) {
  for (var e in s) {
    print(e);
  }
}

avoid_futureor_void

#

不要使用类型 'FutureOr'。

说明

#

当类型 FutureOr<void> 用作结果类型时（准确地说：它在非逆变的位置使用），分析器会生成此诊断信息。类型 FutureOr<void> 有问题，因为它似乎编码结果是 Future<void> ，或者结果应该被丢弃（当它是 `void

除非另有说明，否则本网站上的文档反映的是 Dart 3.6.0。页面最后更新于 2025-02-05。 查看源代码 或 报告问题.