diff --git a/DEPS b/DEPS
index cfd0829..2d8c940 100644
--- a/DEPS
+++ b/DEPS
@@ -133,7 +133,7 @@
   "mime_rev": "c931f4bed87221beaece356494b43731445ce7b8",
   "mockito_rev": "d39ac507483b9891165e422ec98d9fb480037c8b",
   "oauth2_rev": "7cd3284049fe5badbec9f2bea2afc41d14c01057",
-  "package_config_rev": "fb736aa12316dd2d882b202a438a6946a4b4bea0",
+  "package_config_rev": "8731bf10b5375542792a32a0f7c8a6f370583d96",
   "path_rev": "baedce9d2ca11ea2cdf54395a74eb038087777a4",
   "pedantic_rev": "66f2f6c27581c7936482e83be80b27be2719901c",
   "platform_rev": "1ffad63428bbd1b3ecaa15926bacfb724023648c",
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
index 1c50b6a..5841315 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
@@ -79,6 +79,10 @@
           var request = new ExecuteDefinitionsPhaseRequest.deserialize(deserializer, zoneId);
           (await _executeDefinitionsPhase(request, sendRequest)).serialize(serializer);
           break;
+        case MessageType.executeTypesPhaseRequest:
+          var request = new ExecuteTypesPhaseRequest.deserialize(deserializer, zoneId);
+          (await _executeTypesPhase(request, sendRequest)).serialize(serializer);
+          break;
         case MessageType.response:
           var response = new SerializableResponse.deserialize(deserializer, zoneId);
           _responseCompleters.remove(response.requestId)!.complete(response);
@@ -135,6 +139,32 @@
   }
 }
 
+Future<SerializableResponse> _executeTypesPhase(
+    ExecuteTypesPhaseRequest request,
+    Future<Response> Function(Request request) sendRequest) async {
+  try {
+    Macro? instance = _macroInstances[request.macro];
+    if (instance == null) {
+      throw new StateError('Unrecognized macro instance \${request.macro}\\n'
+          'Known instances: \$_macroInstances)');
+    }
+
+    var result = await executeTypesMacro(instance, request.declaration);
+    return new SerializableResponse(
+        responseType: MessageType.macroExecutionResult,
+        response: result,
+        requestId: request.id,
+        serializationZoneId: request.serializationZoneId);
+  } catch (e, s) {
+    return new SerializableResponse(
+      responseType: MessageType.error,
+      error: e.toString(),
+      stackTrace: s.toString(),
+      requestId: request.id,
+      serializationZoneId: request.serializationZoneId);
+  }
+}
+
 Future<SerializableResponse> _executeDeclarationsPhase(
     ExecuteDeclarationsPhaseRequest request,
     Future<Response> Function(Request request) sendRequest) async {
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart
index 59a6376..577e7bf 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart
@@ -24,6 +24,13 @@
       : _augmentations = parentAugmentations ?? [];
 }
 
+class TypeBuilderImpl extends TypeBuilderBase implements TypeBuilder {
+  @override
+  void declareType(DeclarationCode typeDeclaration) {
+    _augmentations.add(typeDeclaration);
+  }
+}
+
 /// Base class for all [DeclarationBuilder]s.
 class DeclarationBuilderBase extends TypeBuilderBase
     implements ClassIntrospector, TypeResolver {
@@ -66,10 +73,8 @@
 class DeclarationBuilderImpl extends DeclarationBuilderBase
     implements DeclarationBuilder {
   DeclarationBuilderImpl(
-      ClassIntrospector classIntrospector, TypeResolver typeResolver,
-      {List<DeclarationCode>? parentAugmentations})
-      : super(classIntrospector, typeResolver,
-            parentAugmentations: parentAugmentations);
+      ClassIntrospector classIntrospector, TypeResolver typeResolver)
+      : super(classIntrospector, typeResolver);
 
   @override
   void declareInLibrary(DeclarationCode declaration) {
@@ -82,10 +87,8 @@
   final TypeAnnotation definingClass;
 
   ClassMemberDeclarationBuilderImpl(this.definingClass,
-      ClassIntrospector classIntrospector, TypeResolver typeResolver,
-      {List<DeclarationCode>? parentAugmentations})
-      : super(classIntrospector, typeResolver,
-            parentAugmentations: parentAugmentations);
+      ClassIntrospector classIntrospector, TypeResolver typeResolver)
+      : super(classIntrospector, typeResolver);
 
   @override
   void declareInClass(DeclarationCode declaration) {
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart
index f94470d..4448b1e 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart
@@ -6,6 +6,38 @@
 import 'package:_fe_analyzer_shared/src/macros/executor_shared/builder_impls.dart';
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
 
+/// Runs [macro] in the types phase and returns a  [MacroExecutionResult].
+Future<MacroExecutionResult> executeTypesMacro(
+    Macro macro, Declaration declaration) async {
+  TypeBuilderImpl builder = new TypeBuilderImpl();
+  if (declaration is FunctionDeclaration) {
+    if (macro is ConstructorTypesMacro &&
+        declaration is ConstructorDeclaration) {
+      await macro.buildTypesForConstructor(declaration, builder);
+      return builder.result;
+    } else if (macro is MethodTypesMacro && declaration is MethodDeclaration) {
+      await macro.buildTypesForMethod(declaration, builder);
+      return builder.result;
+    } else if (macro is FunctionTypesMacro) {
+      await macro.buildTypesForFunction(declaration, builder);
+      return builder.result;
+    }
+  } else if (declaration is VariableDeclaration) {
+    if (macro is FieldTypesMacro && declaration is FieldDeclaration) {
+      await macro.buildTypesForField(declaration, builder);
+      return builder.result;
+    } else if (macro is VariableTypesMacro) {
+      await macro.buildTypesForVariable(declaration, builder);
+      return builder.result;
+    }
+  } else if (macro is ClassTypesMacro && declaration is ClassDeclaration) {
+    await macro.buildTypesForClass(declaration, builder);
+    return builder.result;
+  }
+  throw new UnsupportedError('Unsupported macro type or invalid declaration:\n'
+      'macro: $macro\ndeclaration: $declaration');
+}
+
 /// Runs [macro] in the declaration phase and returns a  [MacroExecutionResult].
 Future<MacroExecutionResult> executeDeclarationsMacro(
     Macro macro,
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
index 3eae69c..00b3787 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
@@ -237,6 +237,32 @@
   }
 }
 
+/// A request to execute a macro on a particular declaration in the types phase.
+class ExecuteTypesPhaseRequest extends Request {
+  final MacroInstanceIdentifier macro;
+  final DeclarationImpl declaration;
+
+  ExecuteTypesPhaseRequest(this.macro, this.declaration,
+      {required int serializationZoneId})
+      : super(serializationZoneId: serializationZoneId);
+
+  /// When deserializing we have already consumed the message type, so we don't
+  /// consume it again.
+  ExecuteTypesPhaseRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
+      : macro = new MacroInstanceIdentifierImpl.deserialize(deserializer),
+        declaration = RemoteInstance.deserialize(deserializer),
+        super.deserialize(deserializer, serializationZoneId);
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.executeTypesPhaseRequest.index);
+    macro.serialize(serializer);
+    declaration.serialize(serializer);
+
+    super.serialize(serializer);
+  }
+}
+
 /// A request to execute a macro on a particular declaration in the definition
 /// phase.
 class ExecuteDeclarationsPhaseRequest extends Request {
@@ -664,6 +690,7 @@
   error,
   executeDeclarationsPhaseRequest,
   executeDefinitionsPhaseRequest,
+  executeTypesPhaseRequest,
   instantiateMacroRequest,
   isExactlyTypeRequest,
   isSubtypeOfRequest,
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
index 9194c7f..210469e 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
@@ -420,10 +420,9 @@
 
   @override
   Future<MacroExecutionResult> executeTypesPhase(
-      MacroInstanceIdentifier macro, Declaration declaration) {
-    // TODO: implement executeTypesPhase
-    throw new UnimplementedError();
-  }
+          MacroInstanceIdentifier macro, DeclarationImpl declaration) =>
+      _sendRequest((zoneId) => new ExecuteTypesPhaseRequest(macro, declaration,
+          serializationZoneId: zoneId));
 
   @override
   Future<MacroInstanceIdentifier> instantiateMacro(
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
index 81aa97f..ce7d844 100644
--- a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
@@ -212,6 +212,35 @@
     var testTypeDeclarationResolver =
         TestTypeDeclarationResolver({myClassStaticType: myClass});
 
+    group('in the types phase', () {
+      test('on methods', () async {
+        var result = await executor.executeTypesPhase(instanceId, myMethod);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyMethod {}'));
+      });
+
+      test('on constructors', () async {
+        var result =
+            await executor.executeTypesPhase(instanceId, myConstructor);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyConstructor {}'));
+      });
+
+      test('on fields', () async {
+        var result = await executor.executeTypesPhase(instanceId, myField);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyField {}'));
+      });
+
+      test('on classes', () async {
+        var result = await executor.executeTypesPhase(instanceId, myClass);
+        expect(
+            result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace(
+                'class MyClassBuilder implements Builder<MyClass> {}'));
+      });
+    });
+
     group('in the declaration phase', () {
       test('on methods', () async {
         var result = await executor.executeDeclarationsPhase(
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart
index b5681aa..222e1cd 100644
--- a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart
@@ -14,16 +14,22 @@
 /// to validate the introspection APIs work as expected.
 class SimpleMacro
     implements
+        ClassTypesMacro,
         ClassDeclarationsMacro,
         ClassDefinitionMacro,
+        ConstructorTypesMacro,
         ConstructorDeclarationsMacro,
         ConstructorDefinitionMacro,
+        FieldTypesMacro,
         FieldDeclarationsMacro,
         FieldDefinitionMacro,
+        FunctionTypesMacro,
         FunctionDeclarationsMacro,
         FunctionDefinitionMacro,
+        MethodTypesMacro,
         MethodDeclarationsMacro,
         MethodDefinitionMacro,
+        VariableTypesMacro,
         VariableDeclarationsMacro,
         VariableDefinitionMacro {
   final int? x;
@@ -236,6 +242,77 @@
       initializer: variable.initializer,
     );
   }
+
+  @override
+  FutureOr<void> buildTypesForClass(
+      ClassDeclaration clazz, TypeBuilder builder) {
+    List<Object> _buildTypeParam(
+        TypeParameterDeclaration typeParam, bool isFirst) {
+      return [
+        if (!isFirst) ', ',
+        typeParam.name,
+        if (typeParam.bounds != null) ...[
+          ' extends ',
+          typeParam.bounds!,
+        ]
+      ];
+    }
+
+    builder.declareType(DeclarationCode.fromParts([
+      'class ${clazz.name}Builder',
+      if (clazz.typeParameters.isNotEmpty) ...[
+        '<',
+        ..._buildTypeParam(clazz.typeParameters.first, true),
+        for (var typeParam in clazz.typeParameters.skip(1))
+          ..._buildTypeParam(typeParam, false),
+        '>',
+      ],
+      ' implements Builder<',
+      clazz.type,
+      if (clazz.typeParameters.isNotEmpty) ...[
+        '<',
+        clazz.typeParameters.first,
+        for (var typeParam in clazz.typeParameters) ', ${typeParam.name}',
+        '>',
+      ],
+      '> {}'
+    ]));
+  }
+
+  @override
+  FutureOr<void> buildTypesForConstructor(
+      ConstructorDeclaration constructor, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${constructor.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForField(
+      FieldDeclaration field, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${field.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForFunction(
+      FunctionDeclaration function, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${function.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForMethod(
+      MethodDeclaration method, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${method.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForVariable(
+      VariableDeclaration variable, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${variable.name.capitalize()} {}'));
+  }
 }
 
 FunctionBodyCode _buildFunctionAugmentation(FunctionDeclaration function) =>
diff --git a/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart b/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart
index fc3a932..873531a 100644
--- a/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart
+++ b/pkg/analyzer/lib/src/dart/error/ffi_code.g.dart
@@ -64,9 +64,43 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field that's declared in a
+  // subclass of `Struct` and has the type `Pointer` also has an annotation
+  // associated with it.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `p`, which
+  // has the type `Pointer` and is declared in a subclass of `Struct`, has the
+  // annotation `@Double()`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   [!@Double()!]
+  //   external Pointer<Int8> p;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove the annotations from the field:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   external Pointer<Int8> p;
+  // }
+  // ```
   static const FfiCode ANNOTATION_ON_POINTER_FIELD = FfiCode(
     'ANNOTATION_ON_POINTER_FIELD',
-    "Fields in a struct class whose type is 'Pointer' should not have any "
+    "Fields in a struct class whose type is 'Pointer' shouldn't have any "
         "annotations.",
     correctionMessage: "Try removing the annotation.",
   );
@@ -75,6 +109,56 @@
    * Parameters:
    * 0: the name of the argument
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when an invocation of either
+  // `Pointer.asFunction` or `DynamicLibrary.lookupFunction` has an `isLeaf`
+  // argument whose value isn't a constant expression.
+  //
+  // The analyzer also produces this diagnostic when the value of the
+  // `exceptionalReturn` argument of `Pointer.fromFunction`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the value of the
+  // `isLeaf` argument is a parameter, and hence isn't a constant:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // int Function(int) fromPointer(
+  //     Pointer<NativeFunction<Int8 Function(Int8)>> p, bool isLeaf) {
+  //   return p.asFunction(isLeaf: [!isLeaf!]);
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If there's a suitable constant that can be used, then replace the argument
+  // with a constant:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // const isLeaf = false;
+  //
+  // int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
+  //   return p.asFunction(isLeaf: isLeaf);
+  // }
+  // ```
+  //
+  // If there isn't a suitable constant, then replace the argument with a
+  // boolean literal:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
+  //   return p.asFunction(isLeaf: true);
+  // }
+  // ```
   static const FfiCode ARGUMENT_MUST_BE_A_CONSTANT = FfiCode(
     'ARGUMENT_MUST_BE_A_CONSTANT',
     "Argument '{0}' must be a constant.",
@@ -84,6 +168,52 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a subclass of either `Struct`
+  // or `Union` is instantiated using a generative constructor.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `C` is being
+  // instantiated using a generative constructor:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int32()
+  //   external int a;
+  // }
+  //
+  // void f() {
+  //   [!C!]();
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If you need to allocate the structure described by the class, then use the
+  // `ffi` package to do so:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  // import 'package:ffi/ffi.dart';
+  //
+  // 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);
+  // }
+  // ```
   static const FfiCode CREATION_OF_STRUCT_OR_UNION = FfiCode(
     'CREATION_OF_STRUCT_OR_UNION',
     "Subclasses of 'Struct' and 'Union' are backed by native memory, and can't "
@@ -97,9 +227,56 @@
    * 0: the name of the subclass
    * 1: the name of the superclass
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a subclass of `Struct` or
+  // `Union` doesn't have any fields. Having an empty `Struct` or `Union`
+  // isn't supported.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `C`, which
+  // extends `Struct`, doesn't declare any fields:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class [!C!] extends Struct {}
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the class is intended to be a struct, then declare one or more fields:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int32()
+  //   external int x;
+  // }
+  // ```
+  //
+  // If the class is intended to be used as a type argument to `Pointer`, then
+  // make it a subclass of `Opaque`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Opaque {}
+  // ```
+  //
+  // If the class isn't intended to be a struct, then remove or change the
+  // extends clause:
+  //
+  // ```dart
+  // class C {}
+  // ```
   static const FfiCode EMPTY_STRUCT = FfiCode(
     'EMPTY_STRUCT',
-    "The class '{0}' can’t be empty because it's a subclass of '{1}'.",
+    "The class '{0}' can't be empty because it's a subclass of '{1}'.",
     correctionMessage:
         "Try adding a field to '{0}' or use a different superclass.",
   );
@@ -107,6 +284,40 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of
+  // `Struct` has more than one annotation describing the native type of the
+  // field.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `x` has two
+  // annotations describing the native type of the field:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int32()
+  //   [!@Int16()!]
+  //   external int x;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove all but one of the annotations:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  // class C extends Struct {
+  //   @Int32()
+  //   external int x;
+  // }
+  // ```
   static const FfiCode EXTRA_ANNOTATION_ON_STRUCT_FIELD = FfiCode(
     'EXTRA_ANNOTATION_ON_STRUCT_FIELD',
     "Fields in a struct class must have exactly one annotation indicating the "
@@ -117,6 +328,41 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of
+  // `Struct` has more than one annotation describing the size of the native
+  // array.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `a0` has two
+  // annotations that specify the size of the native array:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Array(4)
+  //   [!@Array(8)!]
+  //   external Array<Uint8> a0;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove all but one of the annotations:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Array(8)
+  //   external Array<Uint8> a0;
+  // }
+  // ```
   static const FfiCode EXTRA_SIZE_ANNOTATION_CARRAY = FfiCode(
     'EXTRA_SIZE_ANNOTATION_CARRAY',
     "'Array's must have exactly one 'Array' annotation.",
@@ -174,6 +420,45 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a constructor in a subclass of
+  // either `Struct` or `Union` has one or more field initializers.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `C` has a
+  // constructor with an initializer for the field `f`:
+  //
+  // ```dart
+  // // @dart = 2.9
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int32()
+  //   int f;
+  //
+  //   C() : [!f = 0!];
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove the field initializer:
+  //
+  // ```dart
+  // // @dart = 2.9
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int32()
+  //   int f;
+  //
+  //   C();
+  // }
+  // ```
   static const FfiCode FIELD_INITIALIZER_IN_STRUCT = FfiCode(
     'FIELD_INITIALIZER_IN_STRUCT',
     "Constructors in subclasses of 'Struct' and 'Union' can't have field "
@@ -185,6 +470,39 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of
+  // `Struct` has an initializer.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `p` has an
+  // initializer:
+  //
+  // ```dart
+  // // @dart = 2.9
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   Pointer [!p!] = nullptr;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove the initializer:
+  //
+  // ```dart
+  // // @dart = 2.9
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   Pointer p;
+  // }
+  // ```
   static const FfiCode FIELD_IN_STRUCT_WITH_INITIALIZER = FfiCode(
     'FIELD_IN_STRUCT_WITH_INITIALIZER',
     "Fields in subclasses of 'Struct' and 'Union' can't have initializers.",
@@ -195,6 +513,39 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of either
+  // `Struct` or `Union` isn't marked as being `external`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `a` isn't
+  // marked as being `external`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int16()
+  //   int [!a!];
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Add the required `external` modifier:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int16()
+  //   external int a;
+  // }
+  // ```
   static const FfiCode FIELD_MUST_BE_EXTERNAL_IN_STRUCT = FfiCode(
     'FIELD_MUST_BE_EXTERNAL_IN_STRUCT',
     "Fields of 'Struct' and 'Union' subclasses must be marked external.",
@@ -205,20 +556,93 @@
    * Parameters:
    * 0: the name of the struct class
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a subclass of either `Struct`
+  // or `Union` has a type parameter.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `S` defines
+  // the type parameter `T`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class [!S!]<T> extends Struct {
+  //   external Pointer notEmpty;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove the type parameters from the class:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class S extends Struct {
+  //   external Pointer notEmpty;
+  // }
+  // ```
   static const FfiCode GENERIC_STRUCT_SUBCLASS = FfiCode(
     'GENERIC_STRUCT_SUBCLASS',
-    "The class '{0}' can't extend 'Struct' or 'Union' because it is generic.",
+    "The class '{0}' can't extend 'Struct' or 'Union' because '{0}' is "
+        "generic.",
     correctionMessage: "Try removing the type parameters from '{0}'.",
   );
 
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when an invocation of the method
+  // `Pointer.fromFunction` has a second argument (the exceptional return
+  // value) and the type to be returned from the invocation is either `void`,
+  // `Handle` or `Pointer`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because a second argument is
+  // provided when the return type of `f` is `void`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // typedef T = Void Function(Int8);
+  //
+  // void f(int i) {}
+  //
+  // void g() {
+  //   Pointer.fromFunction<T>(f, [!42!]);
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove the exception value:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // typedef T = Void Function(Int8);
+  //
+  // void f(int i) {}
+  //
+  // void g() {
+  //   Pointer.fromFunction<T>(f);
+  // }
+  // ```
   static const FfiCode INVALID_EXCEPTION_VALUE = FfiCode(
     'INVALID_EXCEPTION_VALUE',
-    "The method 'Pointer.fromFunction' must not have an exceptional return "
-        "value (the second argument) when the return type of the function is "
-        "either 'void', 'Handle' or 'Pointer'.",
+    "The method 'Pointer.fromFunction' can't have an exceptional return value "
+        "(the second argument) when the return type of the function is either "
+        "'void', 'Handle' or 'Pointer'.",
     correctionMessage: "Try removing the exceptional return value.",
   );
 
@@ -226,6 +650,46 @@
    * Parameters:
    * 0: the type of the field
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of
+  // `Struct` has a type other than `int`, `double`, `Array`, `Pointer`, or
+  // subtype of `Struct` or `Union`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `str` has
+  // the type `String`, which isn't one of the allowed types for fields in a
+  // subclass of `Struct`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   external [!String!] s;
+  //
+  //   @Int32()
+  //   external int i;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Use one of the allowed types for the field:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  // import 'package:ffi/ffi.dart';
+  //
+  // class C extends Struct {
+  //   external Pointer<Utf8> s;
+  //
+  //   @Int32()
+  //   external int i;
+  // }
+  // ```
   static const FfiCode INVALID_FIELD_TYPE_IN_STRUCT = FfiCode(
     'INVALID_FIELD_TYPE_IN_STRUCT',
     "Fields in struct classes can't have the type '{0}'. They can only be "
@@ -239,27 +703,167 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the value of the `isLeaf`
+  // argument in an invocation of either `Pointer.asFunction` or
+  // `DynamicLibrary.lookupFunction` is `true` and the function that would be
+  // returned would have a return type of `Handle`.
+  //
+  // The analyzer also produces this diagnostic when the value of the `isLeaf`
+  // argument in an `FfiNative` annotation is `true` and the type argument on
+  // the annotation is a function type whose return type is `Handle`.
+  //
+  // In all of these cases, leaf calls are only supported for the types `bool`,
+  // `int`, `float`, `double`, and, as a return type `void`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the function `p`
+  // returns a `Handle`, but the `isLeaf` argument is `true`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // void f(Pointer<NativeFunction<Handle Function()>> p) {
+  //   [!p.asFunction<Object Function()>(isLeaf: true)!];
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the function returns a handle, then remove the `isLeaf` argument:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // void f(Pointer<NativeFunction<Handle Function()>> p) {
+  //   p.asFunction<Object Function()>();
+  // }
+  // ```
+  //
+  // If the function returns one of the supported types, then correct the type
+  // information:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // void f(Pointer<NativeFunction<Int32 Function()>> p) {
+  //   p.asFunction<int Function()>(isLeaf: true);
+  // }
+  // ```
   static const FfiCode LEAF_CALL_MUST_NOT_RETURN_HANDLE = FfiCode(
     'LEAF_CALL_MUST_NOT_RETURN_HANDLE',
-    "FFI leaf call must not return a Handle.",
+    "FFI leaf call can't return a 'Handle'.",
     correctionMessage: "Try changing the return type to primitive or struct.",
   );
 
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the value of the `isLeaf`
+  // argument in an invocation of either `Pointer.asFunction` or
+  // `DynamicLibrary.lookupFunction` is `true` and the function that would be
+  // returned would have a parameter of type `Handle`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the function `p` has a
+  // parameter of type `Handle`, but the `isLeaf` argument is `true`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
+  //   [!p.asFunction<void Function(Object)>(isLeaf: true)!];
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the function has at least one parameter of type `Handle`, then remove
+  // the `isLeaf` argument:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
+  //   p.asFunction<void Function(Object)>();
+  // }
+  // ```
+  //
+  // If none of the function's parameters are `Handle`s, then correct the type
+  // information:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // void f(Pointer<NativeFunction<Void Function(Int8)>> p) {
+  //   p.asFunction<void Function(int)>(isLeaf: true);
+  // }
+  // ```
   static const FfiCode LEAF_CALL_MUST_NOT_TAKE_HANDLE = FfiCode(
     'LEAF_CALL_MUST_NOT_TAKE_HANDLE',
-    "FFI leaf call must not take arguments of type Handle.",
+    "FFI leaf call can't take arguments of type 'Handle'.",
     correctionMessage: "Try changing the argument type to primitive or struct.",
   );
 
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the annotation on a field in a
+  // subclass of `Struct` or `Union` doesn't match the Dart type of the field.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the annotation
+  // `Double` doesn't match the Dart type `int`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   [!@Double()!]
+  //   external int x;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the type of the field is correct, then change the annotation to match:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int32()
+  //   external int x;
+  // }
+  // ```
+  //
+  // If the annotation is correct, then change the type of the field to match:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Double()
+  //   external double x;
+  // }
+  // ```
   static const FfiCode MISMATCHED_ANNOTATION_ON_STRUCT_FIELD = FfiCode(
     'MISMATCHED_ANNOTATION_ON_STRUCT_FIELD',
-    "The annotation does not match the declared type of the field.",
+    "The annotation doesn't match the declared type of the field.",
     correctionMessage:
         "Try using a different annotation or changing the declared type to "
         "match.",
@@ -268,6 +872,41 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of
+  // `Struct` or `Union` whose type requires an annotation doesn't have one.
+  // The Dart types `int`, `double`, and `Array` are used to represent multiple
+  // C types, and the annotation specifies which of the compatible C types the
+  // field represents.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `x` doesn't
+  // have an annotation indicating the underlying width of the integer value:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   external [!int!] x;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Add an appropriate annotation to the field:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int64()
+  //   external int x;
+  // }
+  // ```
   static const FfiCode MISSING_ANNOTATION_ON_STRUCT_FIELD = FfiCode(
     'MISSING_ANNOTATION_ON_STRUCT_FIELD',
     "Fields in a struct class must either have the type 'Pointer' or an "
@@ -278,11 +917,49 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when an invocation of the method
+  // `Pointer.fromFunction` doesn't have a second argument (the exceptional
+  // return value) when the type to be returned from the invocation is neither
+  // `void`, `Handle`, nor `Pointer`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the type returned by
+  // `f` is expected to be an 8-bit integer but the call to `fromFunction`
+  // doesn't include an exceptional return argument:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // int f(int i) => i * 2;
+  //
+  // void g() {
+  //   Pointer.[!fromFunction!]<Int8 Function(Int8)>(f);
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Add an exceptional return type:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // int f(int i) => i * 2;
+  //
+  // void g() {
+  //   Pointer.fromFunction<Int8 Function(Int8)>(f, 0);
+  // }
+  // ```
   static const FfiCode MISSING_EXCEPTION_VALUE = FfiCode(
     'MISSING_EXCEPTION_VALUE',
     "The method 'Pointer.fromFunction' must have an exceptional return value "
         "(the second argument) when the return type of the function is neither "
-        "'void', 'Handle' or 'Pointer'.",
+        "'void', 'Handle', nor 'Pointer'.",
     correctionMessage: "Try adding an exceptional return value.",
   );
 
@@ -290,6 +967,46 @@
    * Parameters:
    * 0: the type of the field
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of
+  // `Struct` or `Union` doesn't have a type annotation. Every field must have
+  // an explicit type, and the type must either be `int`, `double`, `Pointer`,
+  // or a subclass of either `Struct` or `Union`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `str`
+  // doesn't have a type annotation:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   external var [!str!];
+  //
+  //   @Int32()
+  //   external int i;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Explicitly specify the type of the field:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  // import 'package:ffi/ffi.dart';
+  //
+  // class C extends Struct {
+  //   external Pointer<Utf8> str;
+  //
+  //   @Int32()
+  //   external int i;
+  // }
+  // ```
   static const FfiCode MISSING_FIELD_TYPE_IN_STRUCT = FfiCode(
     'MISSING_FIELD_TYPE_IN_STRUCT',
     "Fields in struct classes must have an explicitly declared type of 'int', "
@@ -300,10 +1017,45 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a field in a subclass of either
+  // `Struct` or `Union` has a type of `Array` but doesn't have a single
+  // `Array` annotation indicating the dimensions of the array.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `a0` doesn't
+  // have an `Array` annotation:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   external [!Array<Uint8>!] a0;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Ensure that there's exactly one `Array` annotation on the field:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Array(8)
+  //   external Array<Uint8> a0;
+  // }
+  // ```
   static const FfiCode MISSING_SIZE_ANNOTATION_CARRAY = FfiCode(
     'MISSING_SIZE_ANNOTATION_CARRAY',
-    "'Array's must have exactly one 'Array' annotation.",
-    correctionMessage: "Try adding a 'Array' annotation.",
+    "Fields of type 'Array' must have exactly one 'Array' annotation.",
+    correctionMessage:
+        "Try adding an 'Array' annotation, or removing all but one of the "
+        "annotations.",
   );
 
   /**
@@ -311,6 +1063,47 @@
    * 0: the type that should be a valid dart:ffi native type.
    * 1: the name of the function whose invocation depends on this relationship
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when an invocation of either
+  // `Pointer.fromFunction` or `DynamicLibrary.lookupFunction` has a type
+  // argument(whether explicit or inferred) that isn't a native function type.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the type `T` can be
+  // any subclass of `Function` but the type argument for `fromFunction` is
+  // required to be a native function type:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // int f(int i) => i * 2;
+  //
+  // class C<T extends Function> {
+  //   void g() {
+  //     Pointer.fromFunction<[!T!]>(f, 0);
+  //   }
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Use a native function type as the type argument to the invocation:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // int f(int i) => i * 2;
+  //
+  // class C<T extends Function> {
+  //   void g() {
+  //     Pointer.fromFunction<Int32 Function(Int32)>(f, 0);
+  //   }
+  // }
+  // ```
   static const FfiCode MUST_BE_A_NATIVE_FUNCTION_TYPE = FfiCode(
     'MUST_BE_A_NATIVE_FUNCTION_TYPE',
     "The type '{0}' given to '{1}' must be a valid 'dart:ffi' native function "
@@ -325,6 +1118,64 @@
    * 1: the supertype that the subtype is compared to
    * 2: the name of the function whose invocation depends on this relationship
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic in two cases:
+  // - In an invocation of `Pointer.fromFunction` where the type argument
+  //   (whether explicit or inferred) isn't a supertype of the type of the
+  //   function passed as the first argument to the method.
+  // - In an invocation of `DynamicLibrary.lookupFunction` where the first type
+  //   argument isn't a supertype of the second type argument.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the type of the
+  // function `f` (`String Function(int)`) isn't a subtype of the type
+  // argument `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);
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the function is correct, then change the type argument to match:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // typedef T = Float Function(Float);
+  //
+  // double f(double i) => i;
+  //
+  // void g() {
+  //   Pointer.fromFunction<T>(f, 5.0);
+  // }
+  // ```
+  //
+  // If the type argument is correct, then change the function to match:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // typedef T = Int8 Function(Int8);
+  //
+  // int f(int i) => i;
+  //
+  // void g() {
+  //   Pointer.fromFunction<T>(f, 5);
+  // }
+  // ```
   static const FfiCode MUST_BE_A_SUBTYPE = FfiCode(
     'MUST_BE_A_SUBTYPE',
     "The type '{0}' must be a subtype of '{1}' for '{2}'.",
@@ -335,10 +1186,50 @@
    * Parameters:
    * 0: the name of the function, method, or constructor having type arguments
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the type arguments to a method
+  // are required to be known at compile time, but a type parameter, whose
+  // value can't be known at compile time, is used as a type argument.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the type argument to
+  // `Pointer.asFunction` must be known at compile time, but the type parameter
+  // `R`, which isn't known at compile time, is being used as the type
+  // argument:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // typedef T = int Function(int);
+  //
+  // class C<R extends T> {
+  //   void m(Pointer<NativeFunction<T>> p) {
+  //     p.asFunction<[!R!]>();
+  //   }
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove any uses of type parameters:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C {
+  //   void m(Pointer<NativeFunction<Int64 Function(Int64)>> p) {
+  //     p.asFunction<int Function(int)>();
+  //   }
+  // }
+  // ```
   static const FfiCode NON_CONSTANT_TYPE_ARGUMENT = FfiCode(
     'NON_CONSTANT_TYPE_ARGUMENT',
-    "The type arguments to '{0}' must be compile time constants but type "
-        "parameters are not constants.",
+    "The type arguments to '{0}' must be known at compile time, so they can't "
+        "be type parameters.",
     correctionMessage: "Try changing the type argument to be a constant type.",
   );
 
@@ -346,10 +1237,53 @@
    * Parameters:
    * 0: the type that should be a valid dart:ffi native type.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the method `asFunction` is
+  // invoked on a pointer to a native function, but the signature of the native
+  // function isn't a valid C function signature.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because function signature
+  // associated with the pointer `p` (`FNative`) isn't a valid C function
+  // signature:
+  //
+  // ```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!]>();
+  //   }
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Make the `NativeFunction` signature a valid C signature:
+  //
+  // ```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>();
+  //   }
+  // }
+  // ```
   static const FfiCode NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER = FfiCode(
     'NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER',
-    "The type argument for the pointer '{0}' must be a valid 'NativeFunction' "
-        "in order to use 'asFunction'.",
+    "Can't invoke 'asFunction' because the function signature '{0}' for the "
+        "pointer isn't a valid C function signature.",
     correctionMessage:
         "Try changing the function argument in 'NativeFunction' to only use "
         "NativeTypes.",
@@ -358,6 +1292,39 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a dimension given in an `Array`
+  // annotation is less than or equal to zero (`0`).
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because an array dimension of
+  // `-1` was provided:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class MyStruct extends Struct {
+  //   @Array([!-8!])
+  //   external Array<Uint8> a0;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Change the dimension to be a positive integer:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class MyStruct extends Struct {
+  //   @Array(8)
+  //   external Array<Uint8> a0;
+  // }
+  // ```
   static const FfiCode NON_POSITIVE_ARRAY_DIMENSION = FfiCode(
     'NON_POSITIVE_ARRAY_DIMENSION',
     "Array dimensions must be positive numbers.",
@@ -368,11 +1335,46 @@
    * Parameters:
    * 0: the type of the field
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the type argument for the class
+  // `Array` isn't one of the valid types: either a native integer, `Float`,
+  // `Double`, `Pointer`, or subtype of `Struct`, `Union`, or
+  // `AbiSpecificInteger`.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the type argument to
+  // `Array` is `Void`, and `Void` isn't one of the valid types:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Array(8)
+  //   external Array<[!Void!]> a0;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Change the type argument to one of the valid types:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Array(8)
+  //   external Array<Uint8> a0;
+  // }
+  // ```
   static const FfiCode NON_SIZED_TYPE_ARGUMENT = FfiCode(
     'NON_SIZED_TYPE_ARGUMENT',
-    "Type arguments to '{0}' can't have the type '{1}'. They can only be "
-        "declared as native integer, 'Float', 'Double', 'Pointer', or subtype "
-        "of 'Struct', 'Union', or 'AbiSpecificInteger'.",
+    "The type '{1}' isn't a valid type argument for '{0}'. The type argument "
+        "must be a native integer, 'Float', 'Double', 'Pointer', or subtype of "
+        "'Struct', 'Union', or 'AbiSpecificInteger'.",
     correctionMessage:
         "Try using a native integer, 'Float', 'Double', 'Pointer', or subtype "
         "of 'Struct', 'Union', or 'AbiSpecificInteger'.",
@@ -381,6 +1383,40 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a subclass of `Struct` has more
+  // than one `Packed` annotation.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `C`, which
+  // is a subclass of `Struct`, has two `Packed` annotations:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // @Packed(1)
+  // [!@Packed(1)!]
+  // class C extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove all but one of the annotations:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // @Packed(1)
+  // class C extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  // }
+  // ```
   static const FfiCode PACKED_ANNOTATION = FfiCode(
     'PACKED_ANNOTATION',
     "Structs must have at most one 'Packed' annotation.",
@@ -390,6 +1426,39 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the argument to the `Packed`
+  // annotation isn't one of the allowed values: 1, 2, 4, 8, or 16.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the argument to the
+  // `Packed` annotation (`3`) isn't one of the allowed values:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // @Packed([!3!])
+  // class C extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Change the alignment to be one of the allowed values:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // @Packed(4)
+  // class C extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  // }
+  // ```
   static const FfiCode PACKED_ANNOTATION_ALIGNMENT = FfiCode(
     'PACKED_ANNOTATION_ALIGNMENT',
     "Only packing to 1, 2, 4, 8, and 16 bytes is supported.",
@@ -402,10 +1471,86 @@
    * 0: the name of the outer struct
    * 1: the name of the struct being nested
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a subclass of `Struct` that is
+  // annotated as being `Packed` declares a field whose type is also a subclass
+  // of `Struct` and the field's type is either not packed or is packed less
+  // tightly.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `Outer`,
+  // which is a subclass of `Struct` and is packed on 1-byte boundaries,
+  // declared a field whose type (`Inner`) is packed on 8-byte boundaries:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // @Packed(8)
+  // class Inner extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  // }
+  //
+  // @Packed(1)
+  // class Outer extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  //
+  //   external [!Inner!] nestedLooselyPacked;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the inner struct should be packed more tightly, then change the
+  // argument to the inner struct's `Packed` annotation:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // @Packed(1)
+  // class Inner extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  // }
+  //
+  // @Packed(1)
+  // class Outer extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  //
+  //   external Inner nestedLooselyPacked;
+  // }
+  // ```
+  //
+  // If the outer struct should be packed less tightly, then change the
+  // argument to the outer struct's `Packed` annotation:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // @Packed(8)
+  // class Inner extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  // }
+  //
+  // @Packed(8)
+  // class Outer extends Struct {
+  //   external Pointer<Uint8> notEmpty;
+  //
+  //   external Inner nestedLooselyPacked;
+  // }
+  // ```
+  //
+  // If the inner struct doesn't have an annotation and should be packed, then
+  // add an annotation.
+  //
+  // If the inner struct doesn't have an annotation and the outer struct
+  // shouldn't be packed, then remove its annotation.
   static const FfiCode PACKED_NESTING_NON_PACKED = FfiCode(
     'PACKED_NESTING_NON_PACKED',
     "Nesting the non-packed or less tightly packed struct '{0}' in a packed "
-        "struct '{1}' is not supported.",
+        "struct '{1}' isn't supported.",
     correctionMessage:
         "Try packing the nested struct or packing the nested struct more "
         "tightly.",
@@ -414,6 +1559,53 @@
   /**
    * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the number of dimensions
+  // specified in an `Array` annotation doesn't match the number of nested
+  // arrays specified by the type of a field.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `a0` has a
+  // type with three nested arrays, but only two dimensions are given in the
+  // `Array` annotation:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   [!@Array(8, 8)!]
+  //   external Array<Array<Array<Uint8>>> a0;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the type of the field is correct, then fix the annotation to have the
+  // required number of dimensions:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Array(8, 8, 4)
+  //   external Array<Array<Array<Uint8>>> a0;
+  // }
+  // ```
+  //
+  // If the type of the field is wrong, then fix the type of the field:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Array(8, 8)
+  //   external Array<Array<Uint8>> a0;
+  // }
+  // ```
   static const FfiCode SIZE_ANNOTATION_DIMENSIONS = FfiCode(
     'SIZE_ANNOTATION_DIMENSIONS',
     "'Array's must have an 'Array' annotation that matches the dimensions.",
@@ -425,6 +1617,46 @@
    * 0: the name of the subclass
    * 1: the name of the class being extended, implemented, or mixed in
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a class extends any FFI class
+  // other than `Struct` or `Union`, or implements or mixes in any FFI class.
+  // `Struct` and `Union` are the only FFI classes that can be subtyped, and
+  // then only by extending them.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `C` extends
+  // `Double`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends [!Double!] {}
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the class should extend either `Struct` or `Union`, then change the
+  // declaration of the class:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class C extends Struct {
+  //   @Int32()
+  //   external int i;
+  // }
+  // ```
+  //
+  // If the class shouldn't extend either `Struct` or `Union`, then remove any
+  // references to FFI classes:
+  //
+  // ```dart
+  // class C {}
+  // ```
   static const FfiCode SUBTYPE_OF_FFI_CLASS_IN_EXTENDS = FfiCode(
     'SUBTYPE_OF_FFI_CLASS',
     "The class '{0}' can't extend '{1}'.",
@@ -461,6 +1693,50 @@
    * 0: the name of the subclass
    * 1: the name of the class being extended, implemented, or mixed in
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a class extends, implements, or
+  // mixes in a class that extends either `Struct` or `Union`. Classes can only
+  // extend either `Struct` or `Union` directly.
+  //
+  // For more information about FFI, see [C interop using dart:ffi][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `C` extends
+  // `S`, and `S` extends `Struct`:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class S extends Struct {
+  //   external Pointer f;
+  // }
+  //
+  // class C extends [!S!] {
+  //   external Pointer g;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If you're trying to define a struct or union that shares some fields
+  // declared by a different struct or union, then extend `Struct` or `Union`
+  // directly and copy the shared fields:
+  //
+  // ```dart
+  // import 'dart:ffi';
+  //
+  // class S extends Struct {
+  //   external Pointer f;
+  // }
+  //
+  // class C extends Struct {
+  //   external Pointer f;
+  //
+  //   external Pointer g;
+  // }
+  // ```
   static const FfiCode SUBTYPE_OF_STRUCT_CLASS_IN_EXTENDS = FfiCode(
     'SUBTYPE_OF_STRUCT_CLASS',
     "The class '{0}' can't extend '{1}' because '{1}' is a subtype of "
diff --git a/pkg/analyzer/lib/src/test_utilities/mock_packages.dart b/pkg/analyzer/lib/src/test_utilities/mock_packages.dart
index 84ee9ef..9c4b72b 100644
--- a/pkg/analyzer/lib/src/test_utilities/mock_packages.dart
+++ b/pkg/analyzer/lib/src/test_utilities/mock_packages.dart
@@ -6,6 +6,33 @@
 
 /// Helper for creating mock packages.
 class MockPackages {
+  /// Create a fake 'ffi' package that can be used by tests.
+  static void addFfiPackageFiles(Folder rootFolder) {
+    var libFolder = rootFolder.getChildAssumingFolder('lib');
+    libFolder.getChildAssumingFile('ffi.dart').writeAsStringSync(r'''
+import 'dart:ffi';
+
+const Allocator calloc = _CallocAllocator();
+
+abstract class Allocator {
+  Pointer<T> allocate<T extends NativeType>(int byteCount, {int? alignment});
+
+  void free(Pointer pointer);
+}
+
+class Utf8 extends Opaque {}
+
+class _CallocAllocator implements Allocator {
+  @override
+  Pointer<T> allocate<T extends NativeType>(int byteCount, {int? alignment})
+      => throw '';
+
+  @override
+  void free(Pointer pointer) => throw '';
+}
+''');
+  }
+
   /// Create a fake 'js' package that can be used by tests.
   static void addJsPackageFiles(Folder rootFolder) {
     var libFolder = rootFolder.getChildAssumingFolder('lib');
diff --git a/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart b/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
index e373a74..84784c3 100644
--- a/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
+++ b/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
@@ -662,6 +662,8 @@
 
 class Handle extends NativeType {}
 
+abstract class Opaque extends NativeType {}
+
 class Void extends NativeType {}
 
 class Int8 extends NativeType {
diff --git a/pkg/analyzer/messages.yaml b/pkg/analyzer/messages.yaml
index 1e292cc..f3dcc6d 100644
--- a/pkg/analyzer/messages.yaml
+++ b/pkg/analyzer/messages.yaml
@@ -13822,34 +13822,286 @@
     correctionMessage: Try changing the value to 'Int8', 'Int16', 'Int32', 'Int64', 'Uint8', 'Uint16', 'UInt32', or 'Uint64'.
     comment: No parameters.
   ANNOTATION_ON_POINTER_FIELD:
-    problemMessage: "Fields in a struct class whose type is 'Pointer' should not have any annotations."
+    problemMessage: "Fields in a struct class whose type is 'Pointer' shouldn't have any annotations."
     correctionMessage: Try removing the annotation.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field that's declared in a
+      subclass of `Struct` and has the type `Pointer` also has an annotation
+      associated with it.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `p`, which
+      has the type `Pointer` and is declared in a subclass of `Struct`, has the
+      annotation `@Double()`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        [!@Double()!]
+        external Pointer<Int8> p;
+      }
+      ```
+
+      #### Common fixes
+
+      Remove the annotations from the field:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        external Pointer<Int8> p;
+      }
+      ```
   ARGUMENT_MUST_BE_A_CONSTANT:
     problemMessage: "Argument '{0}' must be a constant."
     correctionMessage: Try replacing the value with a literal or const.
     comment: |-
       Parameters:
       0: the name of the argument
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when an invocation of either
+      `Pointer.asFunction` or `DynamicLibrary.lookupFunction` has an `isLeaf`
+      argument whose value isn't a constant expression.
+
+      The analyzer also produces this diagnostic when the value of the
+      `exceptionalReturn` argument of `Pointer.fromFunction`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the value of the
+      `isLeaf` argument is a parameter, and hence isn't a constant:
+
+      ```dart
+      import 'dart:ffi';
+
+      int Function(int) fromPointer(
+          Pointer<NativeFunction<Int8 Function(Int8)>> p, bool isLeaf) {
+        return p.asFunction(isLeaf: [!isLeaf!]);
+      }
+      ```
+
+      #### Common fixes
+
+      If there's a suitable constant that can be used, then replace the argument
+      with a constant:
+
+      ```dart
+      import 'dart:ffi';
+
+      const isLeaf = false;
+
+      int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
+        return p.asFunction(isLeaf: isLeaf);
+      }
+      ```
+
+      If there isn't a suitable constant, then replace the argument with a
+      boolean literal:
+
+      ```dart
+      import 'dart:ffi';
+
+      int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
+        return p.asFunction(isLeaf: true);
+      }
+      ```
   CREATION_OF_STRUCT_OR_UNION:
     problemMessage: "Subclasses of 'Struct' and 'Union' are backed by native memory, and can't be instantiated by a generative constructor."
     correctionMessage: "Try allocating it via allocation, or load from a 'Pointer'."
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a subclass of either `Struct`
+      or `Union` is instantiated using a generative constructor.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `C` is being
+      instantiated using a generative constructor:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int32()
+        external int a;
+      }
+
+      void f() {
+        [!C!]();
+      }
+      ```
+
+      #### Common fixes
+
+      If you need to allocate the structure described by the class, then use the
+      `ffi` package to do so:
+
+      ```dart
+      import 'dart:ffi';
+      import 'package:ffi/ffi.dart';
+
+      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);
+      }
+      ```
   EMPTY_STRUCT:
-    problemMessage: "The class '{0}' can’t be empty because it's a subclass of '{1}'."
+    problemMessage: "The class '{0}' can't be empty because it's a subclass of '{1}'."
     correctionMessage: "Try adding a field to '{0}' or use a different superclass."
     comment: |-
       Parameters:
       0: the name of the subclass
       1: the name of the superclass
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a subclass of `Struct` or
+      `Union` doesn't have any fields. Having an empty `Struct` or `Union`
+      isn't supported.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `C`, which
+      extends `Struct`, doesn't declare any fields:
+
+      ```dart
+      import 'dart:ffi';
+
+      class [!C!] extends Struct {}
+      ```
+
+      #### Common fixes
+
+      If the class is intended to be a struct, then declare one or more fields:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int32()
+        external int x;
+      }
+      ```
+
+      If the class is intended to be used as a type argument to `Pointer`, then
+      make it a subclass of `Opaque`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Opaque {}
+      ```
+
+      If the class isn't intended to be a struct, then remove or change the
+      extends clause:
+
+      ```dart
+      class C {}
+      ```
   EXTRA_ANNOTATION_ON_STRUCT_FIELD:
     problemMessage: Fields in a struct class must have exactly one annotation indicating the native type.
     correctionMessage: Try removing the extra annotation.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of
+      `Struct` has more than one annotation describing the native type of the
+      field.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `x` has two
+      annotations describing the native type of the field:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int32()
+        [!@Int16()!]
+        external int x;
+      }
+      ```
+
+      #### Common fixes
+
+      Remove all but one of the annotations:
+
+      ```dart
+      import 'dart:ffi';
+      class C extends Struct {
+        @Int32()
+        external int x;
+      }
+      ```
   EXTRA_SIZE_ANNOTATION_CARRAY:
     problemMessage: "'Array's must have exactly one 'Array' annotation."
     correctionMessage: Try removing the extra annotation.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of
+      `Struct` has more than one annotation describing the size of the native
+      array.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `a0` has two
+      annotations that specify the size of the native array:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Array(4)
+        [!@Array(8)!]
+        external Array<Uint8> a0;
+      }
+      ```
+
+      #### Common fixes
+
+      Remove all but one of the annotations:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Array(8)
+        external Array<Uint8> a0;
+      }
+      ```
   FFI_NATIVE_MUST_BE_EXTERNAL:
     problemMessage: FfiNative functions must be declared external.
     correctionMessage: Add the `external` keyword to the function.
@@ -13876,60 +14128,576 @@
     problemMessage: "Constructors in subclasses of 'Struct' and 'Union' can't have field initializers."
     correctionMessage: Try removing the field initializer and marking the field as external.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a constructor in a subclass of
+      either `Struct` or `Union` has one or more field initializers.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `C` has a
+      constructor with an initializer for the field `f`:
+
+      ```dart
+      // @dart = 2.9
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int32()
+        int f;
+
+        C() : [!f = 0!];
+      }
+      ```
+
+      #### Common fixes
+
+      Remove the field initializer:
+
+      ```dart
+      // @dart = 2.9
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int32()
+        int f;
+
+        C();
+      }
+      ```
   FIELD_IN_STRUCT_WITH_INITIALIZER:
     problemMessage: "Fields in subclasses of 'Struct' and 'Union' can't have initializers."
     correctionMessage: Try removing the initializer and marking the field as external.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of
+      `Struct` has an initializer.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `p` has an
+      initializer:
+
+      ```dart
+      // @dart = 2.9
+      import 'dart:ffi';
+
+      class C extends Struct {
+        Pointer [!p!] = nullptr;
+      }
+      ```
+
+      #### Common fixes
+
+      Remove the initializer:
+
+      ```dart
+      // @dart = 2.9
+      import 'dart:ffi';
+
+      class C extends Struct {
+        Pointer p;
+      }
+      ```
   FIELD_MUST_BE_EXTERNAL_IN_STRUCT:
     problemMessage: "Fields of 'Struct' and 'Union' subclasses must be marked external."
     correctionMessage: "Try adding the 'external' modifier."
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of either
+      `Struct` or `Union` isn't marked as being `external`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `a` isn't
+      marked as being `external`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int16()
+        int [!a!];
+      }
+      ```
+
+      #### Common fixes
+
+      Add the required `external` modifier:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int16()
+        external int a;
+      }
+      ```
   GENERIC_STRUCT_SUBCLASS:
-    problemMessage: "The class '{0}' can't extend 'Struct' or 'Union' because it is generic."
+    problemMessage: "The class '{0}' can't extend 'Struct' or 'Union' because '{0}' is generic."
     correctionMessage: "Try removing the type parameters from '{0}'."
     comment: |-
       Parameters:
       0: the name of the struct class
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a subclass of either `Struct`
+      or `Union` has a type parameter.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `S` defines
+      the type parameter `T`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class [!S!]<T> extends Struct {
+        external Pointer notEmpty;
+      }
+      ```
+
+      #### Common fixes
+
+      Remove the type parameters from the class:
+
+      ```dart
+      import 'dart:ffi';
+
+      class S extends Struct {
+        external Pointer notEmpty;
+      }
+      ```
   INVALID_EXCEPTION_VALUE:
-    problemMessage: "The method 'Pointer.fromFunction' must not have an exceptional return value (the second argument) when the return type of the function is either 'void', 'Handle' or 'Pointer'."
+    problemMessage: "The method 'Pointer.fromFunction' can't have an exceptional return value (the second argument) when the return type of the function is either 'void', 'Handle' or 'Pointer'."
     correctionMessage: Try removing the exceptional return value.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when an invocation of the method
+      `Pointer.fromFunction` has a second argument (the exceptional return
+      value) and the type to be returned from the invocation is either `void`,
+      `Handle` or `Pointer`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because a second argument is
+      provided when the return type of `f` is `void`:
+
+      ```dart
+      import 'dart:ffi';
+
+      typedef T = Void Function(Int8);
+
+      void f(int i) {}
+
+      void g() {
+        Pointer.fromFunction<T>(f, [!42!]);
+      }
+      ```
+
+      #### Common fixes
+
+      Remove the exception value:
+
+      ```dart
+      import 'dart:ffi';
+
+      typedef T = Void Function(Int8);
+
+      void f(int i) {}
+
+      void g() {
+        Pointer.fromFunction<T>(f);
+      }
+      ```
   INVALID_FIELD_TYPE_IN_STRUCT:
     problemMessage: "Fields in struct classes can't have the type '{0}'. They can only be declared as 'int', 'double', 'Array', 'Pointer', or subtype of 'Struct' or 'Union'."
     correctionMessage: "Try using 'int', 'double', 'Array', 'Pointer', or subtype of 'Struct' or 'Union'."
     comment: |-
       Parameters:
       0: the type of the field
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of
+      `Struct` has a type other than `int`, `double`, `Array`, `Pointer`, or
+      subtype of `Struct` or `Union`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `str` has
+      the type `String`, which isn't one of the allowed types for fields in a
+      subclass of `Struct`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        external [!String!] s;
+
+        @Int32()
+        external int i;
+      }
+      ```
+
+      #### Common fixes
+
+      Use one of the allowed types for the field:
+
+      ```dart
+      import 'dart:ffi';
+      import 'package:ffi/ffi.dart';
+
+      class C extends Struct {
+        external Pointer<Utf8> s;
+
+        @Int32()
+        external int i;
+      }
+      ```
   LEAF_CALL_MUST_NOT_RETURN_HANDLE:
-    problemMessage: FFI leaf call must not return a Handle.
+    problemMessage: "FFI leaf call can't return a 'Handle'."
     correctionMessage: Try changing the return type to primitive or struct.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the value of the `isLeaf`
+      argument in an invocation of either `Pointer.asFunction` or
+      `DynamicLibrary.lookupFunction` is `true` and the function that would be
+      returned would have a return type of `Handle`.
+
+      The analyzer also produces this diagnostic when the value of the `isLeaf`
+      argument in an `FfiNative` annotation is `true` and the type argument on
+      the annotation is a function type whose return type is `Handle`.
+
+      In all of these cases, leaf calls are only supported for the types `bool`,
+      `int`, `float`, `double`, and, as a return type `void`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the function `p`
+      returns a `Handle`, but the `isLeaf` argument is `true`:
+
+      ```dart
+      import 'dart:ffi';
+
+      void f(Pointer<NativeFunction<Handle Function()>> p) {
+        [!p.asFunction<Object Function()>(isLeaf: true)!];
+      }
+      ```
+
+      #### Common fixes
+
+      If the function returns a handle, then remove the `isLeaf` argument:
+
+      ```dart
+      import 'dart:ffi';
+
+      void f(Pointer<NativeFunction<Handle Function()>> p) {
+        p.asFunction<Object Function()>();
+      }
+      ```
+
+      If the function returns one of the supported types, then correct the type
+      information:
+
+      ```dart
+      import 'dart:ffi';
+
+      void f(Pointer<NativeFunction<Int32 Function()>> p) {
+        p.asFunction<int Function()>(isLeaf: true);
+      }
+      ```
   LEAF_CALL_MUST_NOT_TAKE_HANDLE:
-    problemMessage: FFI leaf call must not take arguments of type Handle.
+    problemMessage: "FFI leaf call can't take arguments of type 'Handle'."
     correctionMessage: Try changing the argument type to primitive or struct.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the value of the `isLeaf`
+      argument in an invocation of either `Pointer.asFunction` or
+      `DynamicLibrary.lookupFunction` is `true` and the function that would be
+      returned would have a parameter of type `Handle`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the function `p` has a
+      parameter of type `Handle`, but the `isLeaf` argument is `true`:
+
+      ```dart
+      import 'dart:ffi';
+
+      void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
+        [!p.asFunction<void Function(Object)>(isLeaf: true)!];
+      }
+      ```
+
+      #### Common fixes
+
+      If the function has at least one parameter of type `Handle`, then remove
+      the `isLeaf` argument:
+
+      ```dart
+      import 'dart:ffi';
+
+      void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
+        p.asFunction<void Function(Object)>();
+      }
+      ```
+
+      If none of the function's parameters are `Handle`s, then correct the type
+      information:
+
+      ```dart
+      import 'dart:ffi';
+
+      void f(Pointer<NativeFunction<Void Function(Int8)>> p) {
+        p.asFunction<void Function(int)>(isLeaf: true);
+      }
+      ```
   MISMATCHED_ANNOTATION_ON_STRUCT_FIELD:
-    problemMessage: The annotation does not match the declared type of the field.
+    problemMessage: "The annotation doesn't match the declared type of the field."
     correctionMessage: Try using a different annotation or changing the declared type to match.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the annotation on a field in a
+      subclass of `Struct` or `Union` doesn't match the Dart type of the field.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the annotation
+      `Double` doesn't match the Dart type `int`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        [!@Double()!]
+        external int x;
+      }
+      ```
+
+      #### Common fixes
+
+      If the type of the field is correct, then change the annotation to match:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int32()
+        external int x;
+      }
+      ```
+
+      If the annotation is correct, then change the type of the field to match:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Double()
+        external double x;
+      }
+      ```
   MISSING_ANNOTATION_ON_STRUCT_FIELD:
     problemMessage: "Fields in a struct class must either have the type 'Pointer' or an annotation indicating the native type."
     correctionMessage: Try adding an annotation.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of
+      `Struct` or `Union` whose type requires an annotation doesn't have one.
+      The Dart types `int`, `double`, and `Array` are used to represent multiple
+      C types, and the annotation specifies which of the compatible C types the
+      field represents.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `x` doesn't
+      have an annotation indicating the underlying width of the integer value:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        external [!int!] x;
+      }
+      ```
+
+      #### Common fixes
+
+      Add an appropriate annotation to the field:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int64()
+        external int x;
+      }
+      ```
   MISSING_EXCEPTION_VALUE:
-    problemMessage: "The method 'Pointer.fromFunction' must have an exceptional return value (the second argument) when the return type of the function is neither 'void', 'Handle' or 'Pointer'."
+    problemMessage: "The method 'Pointer.fromFunction' must have an exceptional return value (the second argument) when the return type of the function is neither 'void', 'Handle', nor 'Pointer'."
     correctionMessage: Try adding an exceptional return value.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when an invocation of the method
+      `Pointer.fromFunction` doesn't have a second argument (the exceptional
+      return value) when the type to be returned from the invocation is neither
+      `void`, `Handle`, nor `Pointer`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the type returned by
+      `f` is expected to be an 8-bit integer but the call to `fromFunction`
+      doesn't include an exceptional return argument:
+
+      ```dart
+      import 'dart:ffi';
+
+      int f(int i) => i * 2;
+
+      void g() {
+        Pointer.[!fromFunction!]<Int8 Function(Int8)>(f);
+      }
+      ```
+
+      #### Common fixes
+
+      Add an exceptional return type:
+
+      ```dart
+      import 'dart:ffi';
+
+      int f(int i) => i * 2;
+
+      void g() {
+        Pointer.fromFunction<Int8 Function(Int8)>(f, 0);
+      }
+      ```
   MISSING_FIELD_TYPE_IN_STRUCT:
     problemMessage: "Fields in struct classes must have an explicitly declared type of 'int', 'double' or 'Pointer'."
     correctionMessage: "Try using 'int', 'double' or 'Pointer'."
     comment: |-
       Parameters:
       0: the type of the field
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of
+      `Struct` or `Union` doesn't have a type annotation. Every field must have
+      an explicit type, and the type must either be `int`, `double`, `Pointer`,
+      or a subclass of either `Struct` or `Union`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `str`
+      doesn't have a type annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        external var [!str!];
+
+        @Int32()
+        external int i;
+      }
+      ```
+
+      #### Common fixes
+
+      Explicitly specify the type of the field:
+
+      ```dart
+      import 'dart:ffi';
+      import 'package:ffi/ffi.dart';
+
+      class C extends Struct {
+        external Pointer<Utf8> str;
+
+        @Int32()
+        external int i;
+      }
+      ```
   MISSING_SIZE_ANNOTATION_CARRAY:
-    problemMessage: "'Array's must have exactly one 'Array' annotation."
-    correctionMessage: "Try adding a 'Array' annotation."
+    problemMessage: "Fields of type 'Array' must have exactly one 'Array' annotation."
+    correctionMessage: "Try adding an 'Array' annotation, or removing all but one of the annotations."
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a field in a subclass of either
+      `Struct` or `Union` has a type of `Array` but doesn't have a single
+      `Array` annotation indicating the dimensions of the array.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `a0` doesn't
+      have an `Array` annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        external [!Array<Uint8>!] a0;
+      }
+      ```
+
+      #### Common fixes
+
+      Ensure that there's exactly one `Array` annotation on the field:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Array(8)
+        external Array<Uint8> a0;
+      }
+      ```
   MUST_BE_A_NATIVE_FUNCTION_TYPE:
     problemMessage: "The type '{0}' given to '{1}' must be a valid 'dart:ffi' native function type."
     correctionMessage: "Try changing the type to only use members for 'dart:ffi'."
@@ -13937,6 +14705,48 @@
       Parameters:
       0: the type that should be a valid dart:ffi native type.
       1: the name of the function whose invocation depends on this relationship
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when an invocation of either
+      `Pointer.fromFunction` or `DynamicLibrary.lookupFunction` has a type
+      argument(whether explicit or inferred) that isn't a native function type.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the type `T` can be
+      any subclass of `Function` but the type argument for `fromFunction` is
+      required to be a native function type:
+
+      ```dart
+      import 'dart:ffi';
+
+      int f(int i) => i * 2;
+
+      class C<T extends Function> {
+        void g() {
+          Pointer.fromFunction<[!T!]>(f, 0);
+        }
+      }
+      ```
+
+      #### Common fixes
+
+      Use a native function type as the type argument to the invocation:
+
+      ```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:
     problemMessage: "The type '{0}' must be a subtype of '{1}' for '{2}'."
     correctionMessage: Try changing one or both of the type arguments.
@@ -13945,47 +14755,455 @@
       0: the type that should be a subtype
       1: the supertype that the subtype is compared to
       2: the name of the function whose invocation depends on this relationship
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic in two cases:
+      - In an invocation of `Pointer.fromFunction` where the type argument
+        (whether explicit or inferred) isn't a supertype of the type of the
+        function passed as the first argument to the method.
+      - In an invocation of `DynamicLibrary.lookupFunction` where the first type
+        argument isn't a supertype of the second type argument.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the type of the
+      function `f` (`String Function(int)`) isn't a subtype of the type
+      argument `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);
+      }
+      ```
+
+      #### Common fixes
+
+      If the function is correct, then change the type argument to match:
+
+      ```dart
+      import 'dart:ffi';
+
+      typedef T = Float Function(Float);
+
+      double f(double i) => i;
+
+      void g() {
+        Pointer.fromFunction<T>(f, 5.0);
+      }
+      ```
+
+      If the type argument is correct, then change the function to match:
+
+      ```dart
+      import 'dart:ffi';
+
+      typedef T = Int8 Function(Int8);
+
+      int f(int i) => i;
+
+      void g() {
+        Pointer.fromFunction<T>(f, 5);
+      }
+      ```
   NON_CONSTANT_TYPE_ARGUMENT:
-    problemMessage: "The type arguments to '{0}' must be compile time constants but type parameters are not constants."
+    problemMessage: "The type arguments to '{0}' must be known at compile time, so they can't be type parameters."
     correctionMessage: Try changing the type argument to be a constant type.
     comment: |-
       Parameters:
       0: the name of the function, method, or constructor having type arguments
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the type arguments to a method
+      are required to be known at compile time, but a type parameter, whose
+      value can't be known at compile time, is used as a type argument.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the type argument to
+      `Pointer.asFunction` must be known at compile time, but the type parameter
+      `R`, which isn't known at compile time, is being used as the type
+      argument:
+
+      ```dart
+      import 'dart:ffi';
+
+      typedef T = int Function(int);
+
+      class C<R extends T> {
+        void m(Pointer<NativeFunction<T>> p) {
+          p.asFunction<[!R!]>();
+        }
+      }
+      ```
+
+      #### Common fixes
+
+      Remove any uses of type parameters:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C {
+        void m(Pointer<NativeFunction<Int64 Function(Int64)>> p) {
+          p.asFunction<int Function(int)>();
+        }
+      }
+      ```
   NON_NATIVE_FUNCTION_TYPE_ARGUMENT_TO_POINTER:
-    problemMessage: "The type argument for the pointer '{0}' must be a valid 'NativeFunction' in order to use 'asFunction'."
+    problemMessage: "Can't invoke 'asFunction' because the function signature '{0}' for the pointer isn't a valid C function signature."
     correctionMessage: "Try changing the function argument in 'NativeFunction' to only use NativeTypes."
     comment: |-
       Parameters:
       0: the type that should be a valid dart:ffi native type.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the method `asFunction` is
+      invoked on a pointer to a native function, but the signature of the native
+      function isn't a valid C function signature.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because function signature
+      associated with the pointer `p` (`FNative`) isn't a valid C function
+      signature:
+
+      ```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!]>();
+        }
+      }
+      ```
+
+      #### Common fixes
+
+      Make the `NativeFunction` signature a valid C signature:
+
+      ```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:
     problemMessage: Array dimensions must be positive numbers.
     correctionMessage: Try changing the input to a positive number.
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a dimension given in an `Array`
+      annotation is less than or equal to zero (`0`).
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because an array dimension of
+      `-1` was provided:
+
+      ```dart
+      import 'dart:ffi';
+
+      class MyStruct extends Struct {
+        @Array([!-8!])
+        external Array<Uint8> a0;
+      }
+      ```
+
+      #### Common fixes
+
+      Change the dimension to be a positive integer:
+
+      ```dart
+      import 'dart:ffi';
+
+      class MyStruct extends Struct {
+        @Array(8)
+        external Array<Uint8> a0;
+      }
+      ```
   NON_SIZED_TYPE_ARGUMENT:
-    problemMessage: "Type arguments to '{0}' can't have the type '{1}'. They can only be declared as native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'."
+    problemMessage: "The type '{1}' isn't a valid type argument for '{0}'. The type argument must be a native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'."
     correctionMessage: "Try using a native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'."
     comment: |-
       Parameters:
       0: the type of the field
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the type argument for the class
+      `Array` isn't one of the valid types: either a native integer, `Float`,
+      `Double`, `Pointer`, or subtype of `Struct`, `Union`, or
+      `AbiSpecificInteger`.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the type argument to
+      `Array` is `Void`, and `Void` isn't one of the valid types:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Array(8)
+        external Array<[!Void!]> a0;
+      }
+      ```
+
+      #### Common fixes
+
+      Change the type argument to one of the valid types:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Array(8)
+        external Array<Uint8> a0;
+      }
+      ```
   PACKED_ANNOTATION:
     problemMessage: "Structs must have at most one 'Packed' annotation."
     correctionMessage: "Try removing extra 'Packed' annotations."
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a subclass of `Struct` has more
+      than one `Packed` annotation.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `C`, which
+      is a subclass of `Struct`, has two `Packed` annotations:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Packed(1)
+      [!@Packed(1)!]
+      class C extends Struct {
+        external Pointer<Uint8> notEmpty;
+      }
+      ```
+
+      #### Common fixes
+
+      Remove all but one of the annotations:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Packed(1)
+      class C extends Struct {
+        external Pointer<Uint8> notEmpty;
+      }
+      ```
   PACKED_ANNOTATION_ALIGNMENT:
     problemMessage: Only packing to 1, 2, 4, 8, and 16 bytes is supported.
     correctionMessage: "Try changing the 'Packed' annotation alignment to 1, 2, 4, 8, or 16."
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the argument to the `Packed`
+      annotation isn't one of the allowed values: 1, 2, 4, 8, or 16.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the argument to the
+      `Packed` annotation (`3`) isn't one of the allowed values:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Packed([!3!])
+      class C extends Struct {
+        external Pointer<Uint8> notEmpty;
+      }
+      ```
+
+      #### Common fixes
+
+      Change the alignment to be one of the allowed values:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Packed(4)
+      class C extends Struct {
+        external Pointer<Uint8> notEmpty;
+      }
+      ```
   PACKED_NESTING_NON_PACKED:
-    problemMessage: "Nesting the non-packed or less tightly packed struct '{0}' in a packed struct '{1}' is not supported."
+    problemMessage: "Nesting the non-packed or less tightly packed struct '{0}' in a packed struct '{1}' isn't supported."
     correctionMessage: Try packing the nested struct or packing the nested struct more tightly.
     comment: |-
       Parameters:
       0: the name of the outer struct
       1: the name of the struct being nested
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a subclass of `Struct` that is
+      annotated as being `Packed` declares a field whose type is also a subclass
+      of `Struct` and the field's type is either not packed or is packed less
+      tightly.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `Outer`,
+      which is a subclass of `Struct` and is packed on 1-byte boundaries,
+      declared a field whose type (`Inner`) is packed on 8-byte boundaries:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Packed(8)
+      class Inner extends Struct {
+        external Pointer<Uint8> notEmpty;
+      }
+
+      @Packed(1)
+      class Outer extends Struct {
+        external Pointer<Uint8> notEmpty;
+
+        external [!Inner!] nestedLooselyPacked;
+      }
+      ```
+
+      #### Common fixes
+
+      If the inner struct should be packed more tightly, then change the
+      argument to the inner struct's `Packed` annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Packed(1)
+      class Inner extends Struct {
+        external Pointer<Uint8> notEmpty;
+      }
+
+      @Packed(1)
+      class Outer extends Struct {
+        external Pointer<Uint8> notEmpty;
+
+        external Inner nestedLooselyPacked;
+      }
+      ```
+
+      If the outer struct should be packed less tightly, then change the
+      argument to the outer struct's `Packed` annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      @Packed(8)
+      class Inner extends Struct {
+        external Pointer<Uint8> notEmpty;
+      }
+
+      @Packed(8)
+      class Outer extends Struct {
+        external Pointer<Uint8> notEmpty;
+
+        external Inner nestedLooselyPacked;
+      }
+      ```
+
+      If the inner struct doesn't have an annotation and should be packed, then
+      add an annotation.
+
+      If the inner struct doesn't have an annotation and the outer struct
+      shouldn't be packed, then remove its annotation.
   SIZE_ANNOTATION_DIMENSIONS:
     problemMessage: "'Array's must have an 'Array' annotation that matches the dimensions."
     correctionMessage: "Try adjusting the arguments in the 'Array' annotation."
     comment: No parameters.
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when the number of dimensions
+      specified in an `Array` annotation doesn't match the number of nested
+      arrays specified by the type of a field.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the field `a0` has a
+      type with three nested arrays, but only two dimensions are given in the
+      `Array` annotation:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        [!@Array(8, 8)!]
+        external Array<Array<Array<Uint8>>> a0;
+      }
+      ```
+
+      #### Common fixes
+
+      If the type of the field is correct, then fix the annotation to have the
+      required number of dimensions:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Array(8, 8, 4)
+        external Array<Array<Array<Uint8>>> a0;
+      }
+      ```
+
+      If the type of the field is wrong, then fix the type of the field:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Array(8, 8)
+        external Array<Array<Uint8>> a0;
+      }
+      ```
   SUBTYPE_OF_FFI_CLASS_IN_EXTENDS:
     sharedName: SUBTYPE_OF_FFI_CLASS
     problemMessage: "The class '{0}' can't extend '{1}'."
@@ -13994,6 +15212,47 @@
       Parameters:
       0: the name of the subclass
       1: the name of the class being extended, implemented, or mixed in
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a class extends any FFI class
+      other than `Struct` or `Union`, or implements or mixes in any FFI class.
+      `Struct` and `Union` are the only FFI classes that can be subtyped, and
+      then only by extending them.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `C` extends
+      `Double`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends [!Double!] {}
+      ```
+
+      #### Common fixes
+
+      If the class should extend either `Struct` or `Union`, then change the
+      declaration of the class:
+
+      ```dart
+      import 'dart:ffi';
+
+      class C extends Struct {
+        @Int32()
+        external int i;
+      }
+      ```
+
+      If the class shouldn't extend either `Struct` or `Union`, then remove any
+      references to FFI classes:
+
+      ```dart
+      class C {}
+      ```
   SUBTYPE_OF_FFI_CLASS_IN_IMPLEMENTS:
     sharedName: SUBTYPE_OF_FFI_CLASS
     problemMessage: "The class '{0}' can't implement '{1}'."
@@ -14018,6 +15277,51 @@
       Parameters:
       0: the name of the subclass
       1: the name of the class being extended, implemented, or mixed in
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a class extends, implements, or
+      mixes in a class that extends either `Struct` or `Union`. Classes can only
+      extend either `Struct` or `Union` directly.
+
+      For more information about FFI, see [C interop using dart:ffi][].
+
+      #### Example
+
+      The following code produces this diagnostic because the class `C` extends
+      `S`, and `S` extends `Struct`:
+
+      ```dart
+      import 'dart:ffi';
+
+      class S extends Struct {
+        external Pointer f;
+      }
+
+      class C extends [!S!] {
+        external Pointer g;
+      }
+      ```
+
+      #### Common fixes
+
+      If you're trying to define a struct or union that shares some fields
+      declared by a different struct or union, then extend `Struct` or `Union`
+      directly and copy the shared fields:
+
+      ```dart
+      import 'dart:ffi';
+
+      class S extends Struct {
+        external Pointer f;
+      }
+
+      class C extends Struct {
+        external Pointer f;
+
+        external Pointer g;
+      }
+      ```
   SUBTYPE_OF_STRUCT_CLASS_IN_IMPLEMENTS:
     sharedName: SUBTYPE_OF_STRUCT_CLASS
     problemMessage: "The class '{0}' can't implement '{1}' because '{1}' is a subtype of 'Struct', 'Union', or 'AbiSpecificInteger'."
diff --git a/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart b/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
index 89c6d3f..3f5a183 100644
--- a/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
@@ -313,6 +313,7 @@
   void writeTestPackageConfig(
     PackageConfigFileBuilder config, {
     String? languageVersion,
+    bool ffi = false,
     bool js = false,
     bool meta = false,
   }) {
@@ -324,6 +325,14 @@
       languageVersion: languageVersion ?? testPackageLanguageVersion,
     );
 
+    if (ffi) {
+      var ffiPath = '/packages/ffi';
+      MockPackages.addFfiPackageFiles(
+        getFolder(ffiPath),
+      );
+      config.add(name: 'ffi', rootPath: ffiPath);
+    }
+
     if (js) {
       var jsPath = '/packages/js';
       MockPackages.addJsPackageFiles(
diff --git a/pkg/analyzer/test/verify_diagnostics_test.dart b/pkg/analyzer/test/verify_diagnostics_test.dart
index d5ee1bf..873f700 100644
--- a/pkg/analyzer/test/verify_diagnostics_test.dart
+++ b/pkg/analyzer/test/verify_diagnostics_test.dart
@@ -451,6 +451,6 @@
         );
       }
     }
-    writeTestPackageConfig(packageConfigBuilder, meta: true);
+    writeTestPackageConfig(packageConfigBuilder, ffi: true, meta: true);
   }
 }
diff --git a/pkg/analyzer/tool/diagnostics/diagnostics.md b/pkg/analyzer/tool/diagnostics/diagnostics.md
index 282257c..c8454b0 100644
--- a/pkg/analyzer/tool/diagnostics/diagnostics.md
+++ b/pkg/analyzer/tool/diagnostics/diagnostics.md
@@ -649,6 +649,101 @@
 }
 {% endprettify %}
 
+### annotation_on_pointer_field
+
+_Fields in a struct class whose type is 'Pointer' shouldn't have any
+annotations._
+
+#### Description
+
+The analyzer produces this diagnostic when a field that's declared in a
+subclass of `Struct` and has the type `Pointer` also has an annotation
+associated with it.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `p`, which
+has the type `Pointer` and is declared in a subclass of `Struct`, has the
+annotation `@Double()`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  [!@Double()!]
+  external Pointer<Int8> p;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove the annotations from the field:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  external Pointer<Int8> p;
+}
+{% endprettify %}
+
+### argument_must_be_a_constant
+
+_Argument '{0}' must be a constant._
+
+#### Description
+
+The analyzer produces this diagnostic when an invocation of either
+`Pointer.asFunction` or `DynamicLibrary.lookupFunction` has an `isLeaf`
+argument whose value isn't a constant expression.
+
+The analyzer also produces this diagnostic when the value of the
+`exceptionalReturn` argument of `Pointer.fromFunction`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the value of the
+`isLeaf` argument is a parameter, and hence isn't a constant:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+int Function(int) fromPointer(
+    Pointer<NativeFunction<Int8 Function(Int8)>> p, bool isLeaf) {
+  return p.asFunction(isLeaf: [!isLeaf!]);
+}
+{% endprettify %}
+
+#### Common fixes
+
+If there's a suitable constant that can be used, then replace the argument
+with a constant:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+const isLeaf = false;
+
+int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
+  return p.asFunction(isLeaf: isLeaf);
+}
+{% endprettify %}
+
+If there isn't a suitable constant, then replace the argument with a
+boolean literal:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+int Function(int) fromPointer(Pointer<NativeFunction<Int8 Function(Int8)>> p) {
+  return p.asFunction(isLeaf: true);
+}
+{% endprettify %}
+
 ### argument_type_not_assignable
 
 _The argument type '{0}' can't be assigned to the parameter type '{1}'._
@@ -2696,6 +2791,58 @@
 C<T> newC<T>() => C<T>();
 {% endprettify %}
 
+### creation_of_struct_or_union
+
+_Subclasses of 'Struct' and 'Union' are backed by native memory, and can't be
+instantiated by a generative constructor._
+
+#### Description
+
+The analyzer produces this diagnostic when a subclass of either `Struct`
+or `Union` is instantiated using a generative constructor.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `C` is being
+instantiated using a generative constructor:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int32()
+  external int a;
+}
+
+void f() {
+  [!C!]();
+}
+{% endprettify %}
+
+#### Common fixes
+
+If you need to allocate the structure described by the class, then use the
+`ffi` package to do so:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+import 'package:ffi/ffi.dart';
+
+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);
+}
+{% endprettify %}
+
 ### creation_with_non_type
 
 _The name '{0}' isn't a class._
@@ -3777,6 +3924,58 @@
 var x = min(2, min(0, 1));
 {% endprettify %}
 
+### empty_struct
+
+_The class '{0}' can't be empty because it's a subclass of '{1}'._
+
+#### Description
+
+The analyzer produces this diagnostic when a subclass of `Struct` or
+`Union` doesn't have any fields. Having an empty `Struct` or `Union`
+isn't supported.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `C`, which
+extends `Struct`, doesn't declare any fields:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class [!C!] extends Struct {}
+{% endprettify %}
+
+#### Common fixes
+
+If the class is intended to be a struct, then declare one or more fields:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int32()
+  external int x;
+}
+{% endprettify %}
+
+If the class is intended to be used as a type argument to `Pointer`, then
+make it a subclass of `Opaque`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Opaque {}
+{% endprettify %}
+
+If the class isn't intended to be a struct, then remove or change the
+extends clause:
+
+{% prettify dart tag=pre+code %}
+class C {}
+{% endprettify %}
+
 ### equal_elements_in_const_set
 
 _Two elements in a constant set literal can't be equal._
@@ -4548,6 +4747,46 @@
 If there are multiple cascaded accesses, you'll need to duplicate the
 extension override for each one.
 
+### extra_annotation_on_struct_field
+
+_Fields in a struct class must have exactly one annotation indicating the native
+type._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of
+`Struct` has more than one annotation describing the native type of the
+field.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `x` has two
+annotations describing the native type of the field:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int32()
+  [!@Int16()!]
+  external int x;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove all but one of the annotations:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+class C extends Struct {
+  @Int32()
+  external int x;
+}
+{% endprettify %}
+
 ### extra_positional_arguments
 
 _Too many positional arguments: {0} expected, but {1} found._
@@ -4625,6 +4864,46 @@
 }
 {% endprettify %}
 
+### extra_size_annotation_carray
+
+_'Array's must have exactly one 'Array' annotation._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of
+`Struct` has more than one annotation describing the size of the native
+array.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `a0` has two
+annotations that specify the size of the native array:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(4)
+  [!@Array(8)!]
+  external Array<Uint8> a0;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove all but one of the annotations:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8)
+  external Array<Uint8> a0;
+}
+{% endprettify %}
+
 ### field_initialized_by_multiple_initializers
 
 _The field '{0}' can't be initialized twice in the same constructor._
@@ -4800,6 +5079,51 @@
 }
 {% endprettify %}
 
+### field_initializer_in_struct
+
+_Constructors in subclasses of 'Struct' and 'Union' can't have field
+initializers._
+
+#### Description
+
+The analyzer produces this diagnostic when a constructor in a subclass of
+either `Struct` or `Union` has one or more field initializers.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `C` has a
+constructor with an initializer for the field `f`:
+
+{% prettify dart tag=pre+code %}
+// @dart = 2.9
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int32()
+  int f;
+
+  C() : [!f = 0!];
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove the field initializer:
+
+{% prettify dart tag=pre+code %}
+// @dart = 2.9
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int32()
+  int f;
+
+  C();
+}
+{% endprettify %}
+
 ### field_initializer_not_assignable
 
 _The initializer type '{0}' can't be assigned to the field type '{1}' in a const
@@ -4981,6 +5305,82 @@
 }
 {% endprettify %}
 
+### field_in_struct_with_initializer
+
+_Fields in subclasses of 'Struct' and 'Union' can't have initializers._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of
+`Struct` has an initializer.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `p` has an
+initializer:
+
+{% prettify dart tag=pre+code %}
+// @dart = 2.9
+import 'dart:ffi';
+
+class C extends Struct {
+  Pointer [!p!] = nullptr;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove the initializer:
+
+{% prettify dart tag=pre+code %}
+// @dart = 2.9
+import 'dart:ffi';
+
+class C extends Struct {
+  Pointer p;
+}
+{% endprettify %}
+
+### field_must_be_external_in_struct
+
+_Fields of 'Struct' and 'Union' subclasses must be marked external._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of either
+`Struct` or `Union` isn't marked as being `external`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `a` isn't
+marked as being `external`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int16()
+  int [!a!];
+}
+{% endprettify %}
+
+#### Common fixes
+
+Add the required `external` modifier:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int16()
+  external int a;
+}
+{% endprettify %}
+
 ### final_initialized_in_declaration_and_constructor
 
 _'{0}' is final and was given a value when it was declared, so it can't be set
@@ -5369,6 +5769,42 @@
 }
 {% endprettify %}
 
+### generic_struct_subclass
+
+_The class '{0}' can't extend 'Struct' or 'Union' because '{0}' is generic._
+
+#### Description
+
+The analyzer produces this diagnostic when a subclass of either `Struct`
+or `Union` has a type parameter.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `S` defines
+the type parameter `T`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class [!S!]<T> extends Struct {
+  external Pointer notEmpty;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove the type parameters from the class:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class S extends Struct {
+  external Pointer notEmpty;
+}
+{% endprettify %}
+
 ### getter_not_subtype_setter_types
 
 _The return type of getter '{0}' is '{1}' which isn't a subtype of the type
@@ -6565,6 +7001,53 @@
     version: ^1.4.0
 ```
 
+### invalid_exception_value
+
+_The method 'Pointer.fromFunction' can't have an exceptional return value (the
+second argument) when the return type of the function is either 'void', 'Handle' or 'Pointer'._
+
+#### Description
+
+The analyzer produces this diagnostic when an invocation of the method
+`Pointer.fromFunction` has a second argument (the exceptional return
+value) and the type to be returned from the invocation is either `void`,
+`Handle` or `Pointer`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because a second argument is
+provided when the return type of `f` is `void`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef T = Void Function(Int8);
+
+void f(int i) {}
+
+void g() {
+  Pointer.fromFunction<T>(f, [!42!]);
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove the exception value:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef T = Void Function(Int8);
+
+void f(int i) {}
+
+void g() {
+  Pointer.fromFunction<T>(f);
+}
+{% endprettify %}
+
 ### invalid_extension_argument_count
 
 _Extension overrides must have exactly one argument: the value of 'this' in the
@@ -6677,6 +7160,52 @@
 }
 {% endprettify %}
 
+### invalid_field_type_in_struct
+
+_Fields in struct classes can't have the type '{0}'. They can only be declared
+as 'int', 'double', 'Array', 'Pointer', or subtype of 'Struct' or 'Union'._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of
+`Struct` has a type other than `int`, `double`, `Array`, `Pointer`, or
+subtype of `Struct` or `Union`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `str` has
+the type `String`, which isn't one of the allowed types for fields in a
+subclass of `Struct`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  external [!String!] s;
+
+  @Int32()
+  external int i;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Use one of the allowed types for the field:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+import 'package:ffi/ffi.dart';
+
+class C extends Struct {
+  external Pointer<Utf8> s;
+
+  @Int32()
+  external int i;
+}
+{% endprettify %}
+
 ### invalid_implementation_override
 
 _'{1}.{0}' ('{2}') isn't a valid concrete implementation of '{3}.{0}' ('{4}')._
@@ -7748,6 +8277,112 @@
 }
 {% endprettify %}
 
+### leaf_call_must_not_return_handle
+
+_FFI leaf call can't return a 'Handle'._
+
+#### Description
+
+The analyzer produces this diagnostic when the value of the `isLeaf`
+argument in an invocation of either `Pointer.asFunction` or
+`DynamicLibrary.lookupFunction` is `true` and the function that would be
+returned would have a return type of `Handle`.
+
+The analyzer also produces this diagnostic when the value of the `isLeaf`
+argument in an `FfiNative` annotation is `true` and the type argument on
+the annotation is a function type whose return type is `Handle`.
+
+In all of these cases, leaf calls are only supported for the types `bool`,
+`int`, `float`, `double`, and, as a return type `void`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the function `p`
+returns a `Handle`, but the `isLeaf` argument is `true`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+void f(Pointer<NativeFunction<Handle Function()>> p) {
+  [!p.asFunction<Object Function()>(isLeaf: true)!];
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the function returns a handle, then remove the `isLeaf` argument:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+void f(Pointer<NativeFunction<Handle Function()>> p) {
+  p.asFunction<Object Function()>();
+}
+{% endprettify %}
+
+If the function returns one of the supported types, then correct the type
+information:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+void f(Pointer<NativeFunction<Int32 Function()>> p) {
+  p.asFunction<int Function()>(isLeaf: true);
+}
+{% endprettify %}
+
+### leaf_call_must_not_take_handle
+
+_FFI leaf call can't take arguments of type 'Handle'._
+
+#### Description
+
+The analyzer produces this diagnostic when the value of the `isLeaf`
+argument in an invocation of either `Pointer.asFunction` or
+`DynamicLibrary.lookupFunction` is `true` and the function that would be
+returned would have a parameter of type `Handle`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the function `p` has a
+parameter of type `Handle`, but the `isLeaf` argument is `true`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
+  [!p.asFunction<void Function(Object)>(isLeaf: true)!];
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the function has at least one parameter of type `Handle`, then remove
+the `isLeaf` argument:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+void f(Pointer<NativeFunction<Void Function(Handle)>> p) {
+  p.asFunction<void Function(Object)>();
+}
+{% endprettify %}
+
+If none of the function's parameters are `Handle`s, then correct the type
+information:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+void f(Pointer<NativeFunction<Void Function(Int8)>> p) {
+  p.asFunction<void Function(int)>(isLeaf: true);
+}
+{% endprettify %}
+
 ### list_element_type_not_assignable
 
 _The element type '{0}' can't be assigned to the list type '{1}'._
@@ -8027,6 +8662,96 @@
 var m = <String, int>{'a' : 2};
 {% endprettify %}
 
+### mismatched_annotation_on_struct_field
+
+_The annotation doesn't match the declared type of the field._
+
+#### Description
+
+The analyzer produces this diagnostic when the annotation on a field in a
+subclass of `Struct` or `Union` doesn't match the Dart type of the field.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the annotation
+`Double` doesn't match the Dart type `int`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  [!@Double()!]
+  external int x;
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the type of the field is correct, then change the annotation to match:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int32()
+  external int x;
+}
+{% endprettify %}
+
+If the annotation is correct, then change the type of the field to match:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Double()
+  external double x;
+}
+{% endprettify %}
+
+### missing_annotation_on_struct_field
+
+_Fields in a struct class must either have the type 'Pointer' or an annotation
+indicating the native type._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of
+`Struct` or `Union` whose type requires an annotation doesn't have one.
+The Dart types `int`, `double`, and `Array` are used to represent multiple
+C types, and the annotation specifies which of the compatible C types the
+field represents.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `x` doesn't
+have an annotation indicating the underlying width of the integer value:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  external [!int!] x;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Add an appropriate annotation to the field:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int64()
+  external int x;
+}
+{% endprettify %}
+
 ### missing_dart_library
 
 _Required library '{0}' is missing._
@@ -8158,6 +8883,96 @@
 }
 {% endprettify %}
 
+### missing_exception_value
+
+_The method 'Pointer.fromFunction' must have an exceptional return value (the
+second argument) when the return type of the function is neither 'void', 'Handle', nor 'Pointer'._
+
+#### Description
+
+The analyzer produces this diagnostic when an invocation of the method
+`Pointer.fromFunction` doesn't have a second argument (the exceptional
+return value) when the type to be returned from the invocation is neither
+`void`, `Handle`, nor `Pointer`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the type returned by
+`f` is expected to be an 8-bit integer but the call to `fromFunction`
+doesn't include an exceptional return argument:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+int f(int i) => i * 2;
+
+void g() {
+  Pointer.[!fromFunction!]<Int8 Function(Int8)>(f);
+}
+{% endprettify %}
+
+#### Common fixes
+
+Add an exceptional return type:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+int f(int i) => i * 2;
+
+void g() {
+  Pointer.fromFunction<Int8 Function(Int8)>(f, 0);
+}
+{% endprettify %}
+
+### missing_field_type_in_struct
+
+_Fields in struct classes must have an explicitly declared type of 'int',
+'double' or 'Pointer'._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of
+`Struct` or `Union` doesn't have a type annotation. Every field must have
+an explicit type, and the type must either be `int`, `double`, `Pointer`,
+or a subclass of either `Struct` or `Union`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `str`
+doesn't have a type annotation:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  external var [!str!];
+
+  @Int32()
+  external int i;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Explicitly specify the type of the field:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+import 'package:ffi/ffi.dart';
+
+class C extends Struct {
+  external Pointer<Utf8> str;
+
+  @Int32()
+  external int i;
+}
+{% endprettify %}
+
 ### missing_name
 
 _The 'name' field is required but missing._
@@ -8289,6 +9104,44 @@
 Add a `return` statement that makes the return value explicit, even if
 `null` is the appropriate value.
 
+### missing_size_annotation_carray
+
+_Fields of type 'Array' must have exactly one 'Array' annotation._
+
+#### Description
+
+The analyzer produces this diagnostic when a field in a subclass of either
+`Struct` or `Union` has a type of `Array` but doesn't have a single
+`Array` annotation indicating the dimensions of the array.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `a0` doesn't
+have an `Array` annotation:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  external [!Array<Uint8>!] a0;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Ensure that there's exactly one `Array` annotation on the field:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8)
+  external Array<Uint8> a0;
+}
+{% endprettify %}
+
 ### mixin_application_concrete_super_invoked_member_type
 
 _The super-invoked member '{0}' has the type '{1}', and the concrete member in
@@ -8820,6 +9673,115 @@
 }
 {% endprettify %}
 
+### must_be_a_native_function_type
+
+_The type '{0}' given to '{1}' must be a valid 'dart:ffi' native function type._
+
+#### Description
+
+The analyzer produces this diagnostic when an invocation of either
+`Pointer.fromFunction` or `DynamicLibrary.lookupFunction` has a type
+argument(whether explicit or inferred) that isn't a native function type.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the type `T` can be
+any subclass of `Function` but the type argument for `fromFunction` is
+required to be a native function type:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+int f(int i) => i * 2;
+
+class C<T extends Function> {
+  void g() {
+    Pointer.fromFunction<[!T!]>(f, 0);
+  }
+}
+{% endprettify %}
+
+#### Common fixes
+
+Use a native function type as the type argument to the invocation:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+int f(int i) => i * 2;
+
+class C<T extends Function> {
+  void g() {
+    Pointer.fromFunction<Int32 Function(Int32)>(f, 0);
+  }
+}
+{% endprettify %}
+
+### must_be_a_subtype
+
+_The type '{0}' must be a subtype of '{1}' for '{2}'._
+
+#### Description
+
+The analyzer produces this diagnostic in two cases:
+- In an invocation of `Pointer.fromFunction` where the type argument
+  (whether explicit or inferred) isn't a supertype of the type of the
+  function passed as the first argument to the method.
+- In an invocation of `DynamicLibrary.lookupFunction` where the first type
+  argument isn't a supertype of the second type argument.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the type of the
+function `f` (`String Function(int)`) isn't a subtype of the type
+argument `T` (`Int8 Function(Int8)`):
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef T = Int8 Function(Int8);
+
+double f(double i) => i;
+
+void g() {
+  Pointer.fromFunction<T>([!f!], 5.0);
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the function is correct, then change the type argument to match:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef T = Float Function(Float);
+
+double f(double i) => i;
+
+void g() {
+  Pointer.fromFunction<T>(f, 5.0);
+}
+{% endprettify %}
+
+If the type argument is correct, then change the function to match:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef T = Int8 Function(Int8);
+
+int f(int i) => i;
+
+void g() {
+  Pointer.fromFunction<T>(f, 5);
+}
+{% endprettify %}
+
 ### must_be_immutable
 
 _This class (or a class that this class inherits from) is marked as
@@ -9640,6 +10602,52 @@
 var s = {i};
 {% endprettify %}
 
+### non_constant_type_argument
+
+_The type arguments to '{0}' must be known at compile time, so they can't be
+type parameters._
+
+#### Description
+
+The analyzer produces this diagnostic when the type arguments to a method
+are required to be known at compile time, but a type parameter, whose
+value can't be known at compile time, is used as a type argument.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the type argument to
+`Pointer.asFunction` must be known at compile time, but the type parameter
+`R`, which isn't known at compile time, is being used as the type
+argument:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef T = int Function(int);
+
+class C<R extends T> {
+  void m(Pointer<NativeFunction<T>> p) {
+    p.asFunction<[!R!]>();
+  }
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove any uses of type parameters:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C {
+  void m(Pointer<NativeFunction<Int64 Function(Int64)>> p) {
+    p.asFunction<int Function(int)>();
+  }
+}
+{% endprettify %}
+
 ### non_const_call_to_literal_constructor
 
 _This instance creation must be 'const', because the {0} constructor is marked
@@ -9728,6 +10736,134 @@
 If the generative constructor is the unnamed constructor, and if there are
 no arguments being passed to it, then you can remove the super invocation.
 
+### non_native_function_type_argument_to_pointer
+
+_Can't invoke 'asFunction' because the function signature '{0}' for the pointer
+isn't a valid C function signature._
+
+#### Description
+
+The analyzer produces this diagnostic when the method `asFunction` is
+invoked on a pointer to a native function, but the signature of the native
+function isn't a valid C function signature.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because function signature
+associated with the pointer `p` (`FNative`) isn't a valid C function
+signature:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef FNative = int Function(int);
+typedef F = int Function(int);
+
+class C {
+  void f(Pointer<NativeFunction<FNative>> p) {
+    p.asFunction<[!F!]>();
+  }
+}
+{% endprettify %}
+
+#### Common fixes
+
+Make the `NativeFunction` signature a valid C signature:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+typedef FNative = Int8 Function(Int8);
+typedef F = int Function(int);
+
+class C {
+  void f(Pointer<NativeFunction<FNative>> p) {
+    p.asFunction<F>();
+  }
+}
+{% endprettify %}
+
+### non_positive_array_dimension
+
+_Array dimensions must be positive numbers._
+
+#### Description
+
+The analyzer produces this diagnostic when a dimension given in an `Array`
+annotation is less than or equal to zero (`0`).
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because an array dimension of
+`-1` was provided:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class MyStruct extends Struct {
+  @Array([!-8!])
+  external Array<Uint8> a0;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Change the dimension to be a positive integer:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class MyStruct extends Struct {
+  @Array(8)
+  external Array<Uint8> a0;
+}
+{% endprettify %}
+
+### non_sized_type_argument
+
+_The type '{1}' isn't a valid type argument for '{0}'. The type argument must be
+a native integer, 'Float', 'Double', 'Pointer', or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'._
+
+#### Description
+
+The analyzer produces this diagnostic when the type argument for the class
+`Array` isn't one of the valid types: either a native integer, `Float`,
+`Double`, `Pointer`, or subtype of `Struct`, `Union`, or
+`AbiSpecificInteger`.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the type argument to
+`Array` is `Void`, and `Void` isn't one of the valid types:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8)
+  external Array<[!Void!]> a0;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Change the type argument to one of the valid types:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8)
+  external Array<Uint8> a0;
+}
+{% endprettify %}
+
 ### non_sync_factory
 
 _Factory bodies can't use 'async', 'async*', or 'sync*'._
@@ -10720,6 +11856,165 @@
 
 If the member can't be removed, then remove the annotation.
 
+### packed_annotation
+
+_Structs must have at most one 'Packed' annotation._
+
+#### Description
+
+The analyzer produces this diagnostic when a subclass of `Struct` has more
+than one `Packed` annotation.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `C`, which
+is a subclass of `Struct`, has two `Packed` annotations:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+@Packed(1)
+[!@Packed(1)!]
+class C extends Struct {
+  external Pointer<Uint8> notEmpty;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove all but one of the annotations:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+@Packed(1)
+class C extends Struct {
+  external Pointer<Uint8> notEmpty;
+}
+{% endprettify %}
+
+### packed_annotation_alignment
+
+_Only packing to 1, 2, 4, 8, and 16 bytes is supported._
+
+#### Description
+
+The analyzer produces this diagnostic when the argument to the `Packed`
+annotation isn't one of the allowed values: 1, 2, 4, 8, or 16.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the argument to the
+`Packed` annotation (`3`) isn't one of the allowed values:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+@Packed([!3!])
+class C extends Struct {
+  external Pointer<Uint8> notEmpty;
+}
+{% endprettify %}
+
+#### Common fixes
+
+Change the alignment to be one of the allowed values:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+@Packed(4)
+class C extends Struct {
+  external Pointer<Uint8> notEmpty;
+}
+{% endprettify %}
+
+### packed_nesting_non_packed
+
+_Nesting the non-packed or less tightly packed struct '{0}' in a packed struct
+'{1}' isn't supported._
+
+#### Description
+
+The analyzer produces this diagnostic when a subclass of `Struct` that is
+annotated as being `Packed` declares a field whose type is also a subclass
+of `Struct` and the field's type is either not packed or is packed less
+tightly.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `Outer`,
+which is a subclass of `Struct` and is packed on 1-byte boundaries,
+declared a field whose type (`Inner`) is packed on 8-byte boundaries:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+@Packed(8)
+class Inner extends Struct {
+  external Pointer<Uint8> notEmpty;
+}
+
+@Packed(1)
+class Outer extends Struct {
+  external Pointer<Uint8> notEmpty;
+
+  external [!Inner!] nestedLooselyPacked;
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the inner struct should be packed more tightly, then change the
+argument to the inner struct's `Packed` annotation:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+@Packed(1)
+class Inner extends Struct {
+  external Pointer<Uint8> notEmpty;
+}
+
+@Packed(1)
+class Outer extends Struct {
+  external Pointer<Uint8> notEmpty;
+
+  external Inner nestedLooselyPacked;
+}
+{% endprettify %}
+
+If the outer struct should be packed less tightly, then change the
+argument to the outer struct's `Packed` annotation:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+@Packed(8)
+class Inner extends Struct {
+  external Pointer<Uint8> notEmpty;
+}
+
+@Packed(8)
+class Outer extends Struct {
+  external Pointer<Uint8> notEmpty;
+
+  external Inner nestedLooselyPacked;
+}
+{% endprettify %}
+
+If the inner struct doesn't have an annotation and should be packed, then
+add an annotation.
+
+If the inner struct doesn't have an annotation and the outer struct
+shouldn't be packed, then remove its annotation.
+
 ### part_of_different_library
 
 _Expected this library to be part of '{0}', not '{1}'._
@@ -12561,6 +13856,58 @@
 var y = convert.json.encode(x.min(0, 1));
 {% endprettify %}
 
+### size_annotation_dimensions
+
+_'Array's must have an 'Array' annotation that matches the dimensions._
+
+#### Description
+
+The analyzer produces this diagnostic when the number of dimensions
+specified in an `Array` annotation doesn't match the number of nested
+arrays specified by the type of a field.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the field `a0` has a
+type with three nested arrays, but only two dimensions are given in the
+`Array` annotation:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  [!@Array(8, 8)!]
+  external Array<Array<Array<Uint8>>> a0;
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the type of the field is correct, then fix the annotation to have the
+required number of dimensions:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8, 8, 4)
+  external Array<Array<Array<Uint8>>> a0;
+}
+{% endprettify %}
+
+If the type of the field is wrong, then fix the type of the field:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Array(8, 8)
+  external Array<Array<Uint8>> a0;
+}
+{% endprettify %}
+
 ### static_access_to_instance_member
 
 _Instance member '{0}' can't be accessed using static access._
@@ -12724,6 +14071,55 @@
 class B {}
 {% endprettify %}
 
+### subtype_of_ffi_class
+
+_The class '{0}' can't extend '{1}'._
+
+_The class '{0}' can't implement '{1}'._
+
+_The class '{0}' can't mix in '{1}'._
+
+#### Description
+
+The analyzer produces this diagnostic when a class extends any FFI class
+other than `Struct` or `Union`, or implements or mixes in any FFI class.
+`Struct` and `Union` are the only FFI classes that can be subtyped, and
+then only by extending them.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `C` extends
+`Double`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends [!Double!] {}
+{% endprettify %}
+
+#### Common fixes
+
+If the class should extend either `Struct` or `Union`, then change the
+declaration of the class:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class C extends Struct {
+  @Int32()
+  external int i;
+}
+{% endprettify %}
+
+If the class shouldn't extend either `Struct` or `Union`, then remove any
+references to FFI classes:
+
+{% prettify dart tag=pre+code %}
+class C {}
+{% endprettify %}
+
 ### subtype_of_sealed_class
 
 _The class '{0}' shouldn't be extended, mixed in, or implemented because it's
@@ -12775,6 +14171,62 @@
 the sealed class so that it's no longer sealed or move the subclass into
 the same package as the sealed class.
 
+### subtype_of_struct_class
+
+_The class '{0}' can't extend '{1}' because '{1}' is a subtype of 'Struct',
+'Union', or 'AbiSpecificInteger'._
+
+_The class '{0}' can't implement '{1}' because '{1}' is a subtype of 'Struct',
+'Union', or 'AbiSpecificInteger'._
+
+_The class '{0}' can't mix in '{1}' because '{1}' is a subtype of 'Struct',
+'Union', or 'AbiSpecificInteger'._
+
+#### Description
+
+The analyzer produces this diagnostic when a class extends, implements, or
+mixes in a class that extends either `Struct` or `Union`. Classes can only
+extend either `Struct` or `Union` directly.
+
+For more information about FFI, see [C interop using dart:ffi][].
+
+#### Example
+
+The following code produces this diagnostic because the class `C` extends
+`S`, and `S` extends `Struct`:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class S extends Struct {
+  external Pointer f;
+}
+
+class C extends [!S!] {
+  external Pointer g;
+}
+{% endprettify %}
+
+#### Common fixes
+
+If you're trying to define a struct or union that shares some fields
+declared by a different struct or union, then extend `Struct` or `Union`
+directly and copy the shared fields:
+
+{% prettify dart tag=pre+code %}
+import 'dart:ffi';
+
+class S extends Struct {
+  external Pointer f;
+}
+
+class C extends Struct {
+  external Pointer f;
+
+  external Pointer g;
+}
+{% endprettify %}
+
 ### supertype_expands_to_type_parameter
 
 _A type alias that expands to a type parameter can't be implemented._
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 1f0baa6..9e8ab9a 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -4129,10 +4129,22 @@
     }
   }
   if (FLAG_verify_acquired_data) {
-    if (external) {
-      ASSERT(!T->heap()->Contains(reinterpret_cast<uword>(data_tmp)));
-    } else {
-      ASSERT(T->heap()->Contains(reinterpret_cast<uword>(data_tmp)));
+    {
+      NoSafepointScope no_safepoint(T);
+      bool sweep_in_progress;
+      {
+        PageSpace* old_space = T->heap()->old_space();
+        MonitorLocker ml(old_space->tasks_lock());
+        sweep_in_progress = (old_space->phase() == PageSpace::kSweepingLarge) ||
+                            (old_space->phase() == PageSpace::kSweepingRegular);
+      }
+      if (!sweep_in_progress) {
+        if (external) {
+          ASSERT(!T->heap()->Contains(reinterpret_cast<uword>(data_tmp)));
+        } else {
+          ASSERT(T->heap()->Contains(reinterpret_cast<uword>(data_tmp)));
+        }
+      }
     }
     const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
     WeakTable* table = I->group()->api_state()->acquired_table();
diff --git a/runtime/vm/heap/pages.cc b/runtime/vm/heap/pages.cc
index 39b1603..476ad6b 100644
--- a/runtime/vm/heap/pages.cc
+++ b/runtime/vm/heap/pages.cc
@@ -1247,16 +1247,39 @@
 
   bool has_reservation = MarkReservation();
 
+  {
+    // Move pages to sweeper work lists.
+    MutexLocker ml(&pages_lock_);
+    ASSERT(sweep_large_ == nullptr);
+    sweep_large_ = large_pages_;
+    large_pages_ = large_pages_tail_ = nullptr;
+    ASSERT(sweep_regular_ == nullptr);
+    if (!compact) {
+      sweep_regular_ = pages_;
+      pages_ = pages_tail_ = nullptr;
+    }
+  }
+
+  bool can_verify;
   if (compact) {
     SweepLarge();
     Compact(thread);
     set_phase(kDone);
+    can_verify = true;
   } else if (FLAG_concurrent_sweep && has_reservation) {
     ConcurrentSweep(isolate_group);
+    can_verify = false;
   } else {
     SweepLarge();
-    Sweep();
+    Sweep(/*exclusive*/ true);
     set_phase(kDone);
+    can_verify = true;
+  }
+
+  if (FLAG_verify_after_gc && can_verify) {
+    OS::PrintErr("Verifying after sweeping...");
+    heap_->VerifyGC(kForbidMarked);
+    OS::PrintErr(" done.\n");
   }
 
   TryReserveForOOM();
@@ -1294,65 +1317,82 @@
   TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "SweepLarge");
 
   GCSweeper sweeper;
-  OldPage* prev_page = nullptr;
-  OldPage* page = large_pages_;
-  while (page != nullptr) {
-    OldPage* next_page = page->next();
-    const intptr_t words_to_end = sweeper.SweepLargePage(page);
+  MutexLocker ml(&pages_lock_);
+  while (sweep_large_ != nullptr) {
+    OldPage* page = sweep_large_;
+    sweep_large_ = page->next();
+    page->set_next(nullptr);
+    ASSERT(page->type() == OldPage::kData);
+
+    ml.Unlock();
+    intptr_t words_to_end = sweeper.SweepLargePage(page);
+    intptr_t size;
     if (words_to_end == 0) {
-      FreeLargePage(page, prev_page);
+      size = page->memory_->size();
+      page->Deallocate();
     } else {
       TruncateLargePage(page, words_to_end << kWordSizeLog2);
-      prev_page = page;
     }
-    // Advance to the next page.
-    page = next_page;
+    ml.Lock();
+
+    if (words_to_end == 0) {
+      IncreaseCapacityInWordsLocked(-(size >> kWordSizeLog2));
+    } else {
+      AddLargePageLocked(page);
+    }
   }
 }
 
-void PageSpace::Sweep() {
+void PageSpace::Sweep(bool exclusive) {
   TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "Sweep");
 
   GCSweeper sweeper;
 
   intptr_t shard = 0;
   const intptr_t num_shards = Utils::Maximum(FLAG_scavenger_tasks, 1);
-  for (intptr_t i = 0; i < num_shards; i++) {
-    DataFreeList(i)->mutex()->Lock();
-  }
-
-  OldPage* prev_page = nullptr;
-  OldPage* page = pages_;
-  while (page != nullptr) {
-    OldPage* next_page = page->next();
-    ASSERT(page->type() == OldPage::kData);
-    shard = (shard + 1) % num_shards;
-    bool page_in_use =
-        sweeper.SweepPage(page, DataFreeList(shard), true /*is_locked*/);
-    if (page_in_use) {
-      prev_page = page;
-    } else {
-      FreePage(page, prev_page);
+  if (exclusive) {
+    for (intptr_t i = 0; i < num_shards; i++) {
+      DataFreeList(i)->mutex()->Lock();
     }
-    // Advance to the next page.
-    page = next_page;
   }
 
-  for (intptr_t i = 0; i < num_shards; i++) {
-    DataFreeList(i)->mutex()->Unlock();
+  MutexLocker ml(&pages_lock_);
+  while (sweep_regular_ != nullptr) {
+    OldPage* page = sweep_regular_;
+    sweep_regular_ = page->next();
+    page->set_next(nullptr);
+    ASSERT(page->type() == OldPage::kData);
+
+    ml.Unlock();
+    // Cycle through the shards round-robin so that free space is roughly
+    // evenly distributed among the freelists and so roughly evenly available
+    // to each scavenger worker.
+    shard = (shard + 1) % num_shards;
+    bool page_in_use = sweeper.SweepPage(page, DataFreeList(shard), exclusive);
+    intptr_t size;
+    if (!page_in_use) {
+      size = page->memory_->size();
+      page->Deallocate();
+    }
+    ml.Lock();
+
+    if (page_in_use) {
+      AddPageLocked(page);
+    } else {
+      IncreaseCapacityInWordsLocked(-(size >> kWordSizeLog2));
+    }
   }
 
-  if (FLAG_verify_after_gc) {
-    OS::PrintErr("Verifying after sweeping...");
-    heap_->VerifyGC(kForbidMarked);
-    OS::PrintErr(" done.\n");
+  if (exclusive) {
+    for (intptr_t i = 0; i < num_shards; i++) {
+      DataFreeList(i)->mutex()->Unlock();
+    }
   }
 }
 
 void PageSpace::ConcurrentSweep(IsolateGroup* isolate_group) {
   // Start the concurrent sweeper task now.
-  GCSweeper::SweepConcurrent(isolate_group, pages_, pages_tail_, large_pages_,
-                             large_pages_tail_, &freelists_[OldPage::kData]);
+  GCSweeper::SweepConcurrent(isolate_group);
 }
 
 void PageSpace::Compact(Thread* thread) {
diff --git a/runtime/vm/heap/pages.h b/runtime/vm/heap/pages.h
index b8e209b..11a4cc2 100644
--- a/runtime/vm/heap/pages.h
+++ b/runtime/vm/heap/pages.h
@@ -576,7 +576,7 @@
                             int64_t pre_wait_for_sweepers,
                             int64_t pre_safe_point);
   void SweepLarge();
-  void Sweep();
+  void Sweep(bool exclusive);
   void ConcurrentSweep(IsolateGroup* isolate_group);
   void Compact(Thread* thread);
 
@@ -614,6 +614,8 @@
   OldPage* large_pages_ = nullptr;
   OldPage* large_pages_tail_ = nullptr;
   OldPage* image_pages_ = nullptr;
+  OldPage* sweep_regular_ = nullptr;
+  OldPage* sweep_large_ = nullptr;
 
   // Various sizes being tracked for this generation.
   intptr_t max_capacity_in_words_;
diff --git a/runtime/vm/heap/sweeper.cc b/runtime/vm/heap/sweeper.cc
index d814521..11900bb 100644
--- a/runtime/vm/heap/sweeper.cc
+++ b/runtime/vm/heap/sweeper.cc
@@ -109,127 +109,54 @@
 
 class ConcurrentSweeperTask : public ThreadPool::Task {
  public:
-  ConcurrentSweeperTask(IsolateGroup* isolate_group,
-                        PageSpace* old_space,
-                        OldPage* first,
-                        OldPage* last,
-                        OldPage* large_first,
-                        OldPage* large_last)
-      : task_isolate_group_(isolate_group),
-        old_space_(old_space),
-        first_(first),
-        last_(last),
-        large_first_(large_first),
-        large_last_(large_last) {
-    ASSERT(task_isolate_group_ != NULL);
-    ASSERT(first_ != NULL);
-    ASSERT(old_space_ != NULL);
-    ASSERT(last_ != NULL);
-    MonitorLocker ml(old_space_->tasks_lock());
-    old_space_->set_tasks(old_space_->tasks() + 1);
-    old_space_->set_phase(PageSpace::kSweepingLarge);
+  explicit ConcurrentSweeperTask(IsolateGroup* isolate_group)
+      : isolate_group_(isolate_group) {
+    ASSERT(isolate_group != nullptr);
+    PageSpace* old_space = isolate_group->heap()->old_space();
+    MonitorLocker ml(old_space->tasks_lock());
+    old_space->set_tasks(old_space->tasks() + 1);
+    old_space->set_phase(PageSpace::kSweepingLarge);
   }
 
   virtual void Run() {
     bool result = Thread::EnterIsolateGroupAsHelper(
-        task_isolate_group_, Thread::kSweeperTask, /*bypass_safepoint=*/true);
+        isolate_group_, Thread::kSweeperTask, /*bypass_safepoint=*/true);
     ASSERT(result);
+    PageSpace* old_space = isolate_group_->heap()->old_space();
     {
       Thread* thread = Thread::Current();
       ASSERT(thread->BypassSafepoints());  // Or we should be checking in.
       TIMELINE_FUNCTION_GC_DURATION(thread, "ConcurrentSweep");
-      GCSweeper sweeper;
 
-      OldPage* page = large_first_;
-      OldPage* prev_page = NULL;
-      while (page != NULL) {
-        OldPage* next_page;
-        if (page == large_last_) {
-          // Don't access page->next(), which would be a race with mutator
-          // allocating new pages.
-          next_page = NULL;
-        } else {
-          next_page = page->next();
-        }
-        ASSERT(page->type() == OldPage::kData);
-        const intptr_t words_to_end = sweeper.SweepLargePage(page);
-        if (words_to_end == 0) {
-          old_space_->FreeLargePage(page, prev_page);
-        } else {
-          old_space_->TruncateLargePage(page, words_to_end << kWordSizeLog2);
-          prev_page = page;
-        }
-        page = next_page;
-      }
+      old_space->SweepLarge();
 
       {
-        MonitorLocker ml(old_space_->tasks_lock());
-        ASSERT(old_space_->phase() == PageSpace::kSweepingLarge);
-        old_space_->set_phase(PageSpace::kSweepingRegular);
+        MonitorLocker ml(old_space->tasks_lock());
+        ASSERT(old_space->phase() == PageSpace::kSweepingLarge);
+        old_space->set_phase(PageSpace::kSweepingRegular);
         ml.NotifyAll();
       }
 
-      intptr_t shard = 0;
-      const intptr_t num_shards = Utils::Maximum(FLAG_scavenger_tasks, 1);
-      page = first_;
-      prev_page = NULL;
-      while (page != NULL) {
-        OldPage* next_page;
-        if (page == last_) {
-          // Don't access page->next(), which would be a race with mutator
-          // allocating new pages.
-          next_page = NULL;
-        } else {
-          next_page = page->next();
-        }
-        ASSERT(page->type() == OldPage::kData);
-        shard = (shard + 1) % num_shards;
-        bool page_in_use =
-            sweeper.SweepPage(page, old_space_->DataFreeList(shard), false);
-        if (page_in_use) {
-          prev_page = page;
-        } else {
-          old_space_->FreePage(page, prev_page);
-        }
-        {
-          // Notify the mutator thread that we have added elements to the free
-          // list or that more capacity is available.
-          MonitorLocker ml(old_space_->tasks_lock());
-          ml.Notify();
-        }
-        page = next_page;
-      }
+      old_space->Sweep(/*exclusive*/ false);
     }
     // Exit isolate cleanly *before* notifying it, to avoid shutdown race.
     Thread::ExitIsolateGroupAsHelper(/*bypass_safepoint=*/true);
     // This sweeper task is done. Notify the original isolate.
     {
-      MonitorLocker ml(old_space_->tasks_lock());
-      old_space_->set_tasks(old_space_->tasks() - 1);
-      ASSERT(old_space_->phase() == PageSpace::kSweepingRegular);
-      old_space_->set_phase(PageSpace::kDone);
+      MonitorLocker ml(old_space->tasks_lock());
+      old_space->set_tasks(old_space->tasks() - 1);
+      ASSERT(old_space->phase() == PageSpace::kSweepingRegular);
+      old_space->set_phase(PageSpace::kDone);
       ml.NotifyAll();
     }
   }
 
  private:
-  IsolateGroup* task_isolate_group_;
-  PageSpace* old_space_;
-  OldPage* first_;
-  OldPage* last_;
-  OldPage* large_first_;
-  OldPage* large_last_;
+  IsolateGroup* isolate_group_;
 };
 
-void GCSweeper::SweepConcurrent(IsolateGroup* isolate_group,
-                                OldPage* first,
-                                OldPage* last,
-                                OldPage* large_first,
-                                OldPage* large_last,
-                                FreeList* freelist) {
-  bool result = Dart::thread_pool()->Run<ConcurrentSweeperTask>(
-      isolate_group, isolate_group->heap()->old_space(), first, last,
-      large_first, large_last);
+void GCSweeper::SweepConcurrent(IsolateGroup* isolate_group) {
+  bool result = Dart::thread_pool()->Run<ConcurrentSweeperTask>(isolate_group);
   ASSERT(result);
 }
 
diff --git a/runtime/vm/heap/sweeper.h b/runtime/vm/heap/sweeper.h
index ca9b6c4..8b781d4 100644
--- a/runtime/vm/heap/sweeper.h
+++ b/runtime/vm/heap/sweeper.h
@@ -34,13 +34,8 @@
   // last marked object.
   intptr_t SweepLargePage(OldPage* page);
 
-  // Sweep the regular sized data pages between first and last inclusive.
-  static void SweepConcurrent(IsolateGroup* isolate_group,
-                              OldPage* first,
-                              OldPage* last,
-                              OldPage* large_first,
-                              OldPage* large_last,
-                              FreeList* freelist);
+  // Sweep the large and regular sized data pages.
+  static void SweepConcurrent(IsolateGroup* isolate_group);
 };
 
 }  // namespace dart
diff --git a/tools/VERSION b/tools/VERSION
index 97705ad..3a2798d 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 53
+PRERELEASE 54
 PRERELEASE_PATCH 0
\ No newline at end of file