diff --git a/analysis_options.yaml b/analysis_options.yaml
index ba5e0a9..87f7d6f 100644
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@@ -9,23 +9,21 @@
 
 # Specify analysis options.
 #
-# Until there are meta linter rules, each desired lint must be explicitly enabled.
-# See: https://github.com/dart-lang/linter/issues/288
-#
 # For a list of lints, see: http://dart-lang.github.io/linter/lints/
 # See the configuration guide for more
-# https://github.com/dart-lang/sdk/tree/master/pkg/analyzer#configuring-the-analyzer
+# https://github.com/dart-lang/sdk/tree/main/pkg/analyzer#configuring-the-analyzer
 #
 # There are other similar analysis options files in the flutter repos,
 # which should be kept in sync with this file:
 #
 #   - analysis_options.yaml (this file)
 #   - packages/flutter/lib/analysis_options_user.yaml
-#   - https://github.com/flutter/plugins/blob/master/analysis_options.yaml
-#   - https://github.com/flutter/engine/blob/master/analysis_options.yaml
+#   - https://github.com/flutter/flutter/blob/master/analysis_options.yaml
+#   - https://github.com/flutter/engine/blob/main/analysis_options.yaml
+#   - https://github.com/flutter/packages/blob/main/analysis_options.yaml
 #
-# This file contains the analysis options used by Flutter tools, such as IntelliJ,
-# Android Studio, and the `flutter analyze` command.
+# This file contains the analysis options used for code in the flutter/plugins
+# repository.
 
 analyzer:
   strong-mode:
@@ -36,7 +34,7 @@
     missing_required_param: warning
     # treat missing returns as a warning (not a hint)
     missing_return: warning
-    # allow having TODOs in the code
+    # allow having TODO comments in the code
     todo: ignore
     # allow self-reference to deprecated members (we do this because otherwise we have
     # to annotate every member in every test, assert, etc, when we deprecate something)
@@ -45,9 +43,10 @@
     # Stream and not importing dart:async
     # Please see https://github.com/flutter/flutter/pull/24528 for details.
     sdk_version_async_exported_from_core: ignore
+    # Turned off until null-safe rollout is complete.
+    unnecessary_null_comparison: ignore
     ### Local flutter/plugins changes ###
     # Allow null checks for as long as mixed mode is officially supported.
-    unnecessary_null_comparison: false
     always_require_non_null_named_parameters: false # not needed with nnbd
   exclude:
     # Ignore generated files
@@ -58,8 +57,7 @@
 
 linter:
   rules:
-    # these rules are documented on and in the same order as
-    # the Dart Lint rules page to make maintenance easier
+    # This list is derived from the list of all available lints located at
     # https://github.com/dart-lang/linter/blob/master/example/all.yaml
     - always_declare_return_types
     - always_put_control_body_on_new_line
@@ -69,62 +67,68 @@
     # - always_use_package_imports # we do this commonly
     - annotate_overrides
     # - avoid_annotating_with_dynamic # conflicts with always_specify_types
-    # - avoid_as # required for implicit-casts: true
     - avoid_bool_literals_in_conditional_expressions
-    # - avoid_catches_without_on_clauses # we do this commonly
-    # - avoid_catching_errors # we do this commonly
+    # - avoid_catches_without_on_clauses # blocked on https://github.com/dart-lang/linter/issues/3023
+    # - avoid_catching_errors # blocked on https://github.com/dart-lang/linter/issues/3023
     - avoid_classes_with_only_static_members
-    # - avoid_double_and_int_checks # only useful when targeting JS runtime
+    - avoid_double_and_int_checks
+    # - avoid_dynamic_calls # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - avoid_empty_else
     - avoid_equals_and_hash_code_on_mutable_classes
-    # - avoid_escaping_inner_quotes # not yet tested
+    - avoid_escaping_inner_quotes
     - avoid_field_initializers_in_const_classes
+    # - avoid_final_parameters # incompatible with prefer_final_parameters
     - avoid_function_literals_in_foreach_calls
-    # - avoid_implementing_value_types # not yet tested
+    # - avoid_implementing_value_types # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - avoid_init_to_null
-    # - avoid_js_rounded_ints # only useful when targeting JS runtime
+    - avoid_js_rounded_ints
+    # - avoid_multiple_declarations_per_line # seems to be a stylistic choice we don't subscribe to
     - avoid_null_checks_in_equality_operators
-    # - avoid_positional_boolean_parameters # not yet tested
-    # - avoid_print # not yet tested
+    # - avoid_positional_boolean_parameters # would have been nice to enable this but by now there's too many places that break it
+    # - avoid_print # LOCAL CHANGE - Needs to be enabled and violations fixed.
     # - avoid_private_typedef_functions # we prefer having typedef (discussion in https://github.com/flutter/flutter/pull/16356)
-    # - avoid_redundant_argument_values # not yet tested
+    # - avoid_redundant_argument_values # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - avoid_relative_lib_imports
     - avoid_renaming_method_parameters
     - avoid_return_types_on_setters
-    # - avoid_returning_null # there are plenty of valid reasons to return null
-    # - avoid_returning_null_for_future # not yet tested
+    # - avoid_returning_null # still violated by some pre-nnbd code that we haven't yet migrated
+    - avoid_returning_null_for_future
     - avoid_returning_null_for_void
-    # - avoid_returning_this # there are plenty of valid reasons to return this
-    # - avoid_setters_without_getters # not yet tested
+    # - avoid_returning_this # there are enough valid reasons to return `this` that this lint ends up with too many false positives
+    - avoid_setters_without_getters
     - avoid_shadowing_type_parameters
     - avoid_single_cascade_in_expression_statements
     - avoid_slow_async_io
-    # - avoid_type_to_string # we do this commonly
+    - avoid_type_to_string
     - avoid_types_as_parameter_names
     # - avoid_types_on_closure_parameters # conflicts with always_specify_types
-    # - avoid_unnecessary_containers # not yet tested
+    - avoid_unnecessary_containers
     - avoid_unused_constructor_parameters
     - avoid_void_async
-    # - avoid_web_libraries_in_flutter # not yet tested
+    # - avoid_web_libraries_in_flutter # we use web libraries in web-specific code, and our tests prevent us from using them elsewhere
     - await_only_futures
     - camel_case_extensions
     - camel_case_types
     - cancel_subscriptions
-    # - cascade_invocations # not yet tested
+    # - cascade_invocations # doesn't match the typical style of this repo
     - cast_nullable_to_non_nullable
     # - close_sinks # not reliable enough
-    # - comment_references # blocked on https://github.com/flutter/flutter/issues/20765
+    # - comment_references # blocked on https://github.com/dart-lang/linter/issues/1142
+    # - conditional_uri_does_not_exist # not yet tested
     # - constant_identifier_names # needs an opt-out https://github.com/dart-lang/linter/issues/204
     - control_flow_in_finally
     # - curly_braces_in_flow_control_structures # not required by flutter style
-    # - diagnostic_describe_all_properties # not yet tested
+    # - depend_on_referenced_packages # LOCAL CHANGE - Needs to be enabled and violations fixed.
+    - deprecated_consistency
+    # - diagnostic_describe_all_properties # enabled only at the framework level (packages/flutter/lib)
     - directives_ordering
-    # - do_not_use_environment # we do this commonly
+    # - do_not_use_environment # there are appropriate times to use the environment, especially in our tests and build logic
     - empty_catches
     - empty_constructor_bodies
     - empty_statements
+    - eol_at_end_of_file
     - exhaustive_cases
-    # - file_names # not yet tested
+    - file_names
     - flutter_style_todos
     - hash_and_equals
     - implementation_imports
@@ -137,22 +141,25 @@
     - library_private_types_in_public_api
     # - lines_longer_than_80_chars # not required by flutter style
     - list_remove_unrelated_type
-    # - literal_only_boolean_expressions # too many false positives: https://github.com/dart-lang/sdk/issues/34181
-    # - missing_whitespace_between_adjacent_strings # not yet tested
+    # - literal_only_boolean_expressions # too many false positives: https://github.com/dart-lang/linter/issues/453
+    - missing_whitespace_between_adjacent_strings
     - no_adjacent_strings_in_list
-    # - no_default_cases # too many false positives
+    # - no_default_cases # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - no_duplicate_case_values
+    - no_leading_underscores_for_library_prefixes
+    # - no_leading_underscores_for_local_identifiers # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - no_logic_in_create_state
     # - no_runtimeType_toString # ok in tests; we enable this only in packages/
     - non_constant_identifier_names
+    - noop_primitive_operations
     - null_check_on_nullable_type_parameter
-    # - null_closures # not required by flutter style
+    - null_closures
     # - omit_local_variable_types # opposite of always_specify_types
     # - one_member_abstracts # too many false positives
-    # - only_throw_errors # https://github.com/flutter/flutter/issues/5792
+    # - only_throw_errors # this does get disabled in a few places where we have legacy code that uses strings et al # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - overridden_fields
     - package_api_docs
-    # - package_names # non conforming packages in sdk
+    - package_names
     - package_prefixed_library_names
     # - parameter_assignments # we do this commonly
     - prefer_adjacent_string_concatenation
@@ -172,74 +179,90 @@
     - prefer_final_fields
     - prefer_final_in_for_each
     - prefer_final_locals
+    # - prefer_final_parameters # we should enable this one day when it can be auto-fixed (https://github.com/dart-lang/linter/issues/3104), see also parameter_assignments
     - prefer_for_elements_to_map_fromIterable
     - prefer_foreach
-    # - prefer_function_declarations_over_variables # not yet tested
+    - prefer_function_declarations_over_variables
     - prefer_generic_function_type_aliases
     - prefer_if_elements_to_conditional_expressions
     - prefer_if_null_operators
     - prefer_initializing_formals
     - prefer_inlined_adds
-    # - prefer_int_literals # not yet tested
-    # - prefer_interpolation_to_compose_strings # not yet tested
+    # - prefer_int_literals # conflicts with https://github.com/flutter/flutter/wiki/Style-guide-for-Flutter-repo#use-double-literals-for-double-constants
+    - prefer_interpolation_to_compose_strings
     - prefer_is_empty
     - prefer_is_not_empty
     - prefer_is_not_operator
     - prefer_iterable_whereType
-    # - prefer_mixin # https://github.com/dart-lang/language/issues/32
-    # - prefer_null_aware_operators # disable until NNBD, see https://github.com/flutter/flutter/pull/32711#issuecomment-492930932
-    # - prefer_relative_imports # not yet tested
+    # - prefer_mixin # Has false positives, see https://github.com/dart-lang/linter/issues/3018
+    # - prefer_null_aware_method_calls # "call()" is confusing to people new to the language since it's not documented anywhere
+    - prefer_null_aware_operators
+    # - prefer_relative_imports # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - prefer_single_quotes
     - prefer_spread_collections
     - prefer_typing_uninitialized_variables
     - prefer_void_to_null
-    # - provide_deprecation_message # not yet tested
+    - provide_deprecation_message
     # - public_member_api_docs # enabled on a case-by-case basis; see e.g. packages/analysis_options.yaml
     - recursive_getters
-    # - sized_box_for_whitespace # not yet tested
+    # - require_trailing_commas # blocked on https://github.com/dart-lang/sdk/issues/47441
+    - secure_pubspec_urls
+    # - sized_box_for_whitespace # LOCAL CHANGE - Needs to be enabled and violations fixed.
+    # - sized_box_shrink_expand # not yet tested
     - slash_for_doc_comments
     - sort_child_properties_last
     - sort_constructors_first
+    # - sort_pub_dependencies # prevents separating pinned transitive dependencies
     - sort_unnamed_constructors_first
     - test_types_in_equals
     - throw_in_finally
     - tighten_type_of_initializing_formals
     # - type_annotate_public_apis # subset of always_specify_types
     - type_init_formals
-    # - unawaited_futures # too many false positives
-    # - unnecessary_await_in_return # not yet tested
+    # - unawaited_futures # too many false positives, especially with the way AnimationController works
+    # - unnecessary_await_in_return # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - unnecessary_brace_in_string_interps
     - unnecessary_const
+    - unnecessary_constructor_name
     # - unnecessary_final # conflicts with prefer_final_locals
     - unnecessary_getters_setters
     # - unnecessary_lambdas # has false positives: https://github.com/dart-lang/linter/issues/498
+    - unnecessary_late
     - unnecessary_new
     - unnecessary_null_aware_assignments
-    # - unnecessary_null_checks # not yet tested
+    - unnecessary_null_checks
     - unnecessary_null_in_if_null_operators
     - unnecessary_nullable_for_final_variable_declarations
     - unnecessary_overrides
     - unnecessary_parenthesis
-    # - unnecessary_raw_strings # not yet tested
+    # - unnecessary_raw_strings # what's "necessary" is a matter of opinion; consistency across strings can help readability more than this lint
     - unnecessary_statements
     - unnecessary_string_escapes
     - unnecessary_string_interpolations
     - unnecessary_this
     - unrelated_type_equality_checks
-    # - unsafe_html # not yet tested
+    - unsafe_html
+    # - use_build_context_synchronously # LOCAL CHANGE - Needs to be enabled and violations fixed.
+    # - use_colored_box # not yet tested
+    # - use_decorated_box # not yet tested
+    # - use_enums # not yet tested
     - use_full_hex_values_for_flutter_colors
-    # - use_function_type_syntax_for_parameters # not yet tested
+    - use_function_type_syntax_for_parameters
+    - use_if_null_to_convert_nulls_to_bools
     - use_is_even_rather_than_modulo
     - use_key_in_widget_constructors
     - use_late_for_private_fields_and_variables
+    # - use_named_constants # LOCAL CHANGE - Needs to be enabled and violations fixed.
     - use_raw_strings
     - use_rethrow_when_possible
-    # - use_setters_to_change_properties # not yet tested
+    - use_setters_to_change_properties
     # - use_string_buffers # has false positives: https://github.com/dart-lang/sdk/issues/34182
+    - use_super_parameters
+    - use_test_throws_matchers
     # - use_to_and_as_if_applicable # has false positives, so we prefer to catch this by code-review
     - valid_regexps
     - void_checks
-    ### Local flutter/plugins changes ###
+    ### Local flutter/plugins additions ###
     # These are from flutter/flutter/packages, so will need to be preserved
     # separately when moving to a shared file.
     - no_runtimeType_toString # use objectRuntimeType from package:foundation
diff --git a/packages/camera/camera/CHANGELOG.md b/packages/camera/camera/CHANGELOG.md
index bf0ccf8..4715644 100644
--- a/packages/camera/camera/CHANGELOG.md
+++ b/packages/camera/camera/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.9.4+23
+
+* Minor fixes for new analysis options.
+
 ## 0.9.4+22
 
 * Removes unnecessary imports.
diff --git a/packages/camera/camera/example/lib/main.dart b/packages/camera/camera/example/lib/main.dart
index a645326..10a8a6f 100644
--- a/packages/camera/camera/example/lib/main.dart
+++ b/packages/camera/camera/example/lib/main.dart
@@ -575,14 +575,13 @@
   Widget _cameraTogglesRowWidget() {
     final List<Widget> toggles = <Widget>[];
 
-    final Null Function(CameraDescription? description) onChanged =
-        (CameraDescription? description) {
+    void onChanged(CameraDescription? description) {
       if (description == null) {
         return;
       }
 
       onNewCameraSelected(description);
-    };
+    }
 
     if (_cameras.isEmpty) {
       _ambiguate(SchedulerBinding.instance)?.addPostFrameCallback((_) async {
diff --git a/packages/camera/camera/pubspec.yaml b/packages/camera/camera/pubspec.yaml
index fde6663..9d56f1b 100644
--- a/packages/camera/camera/pubspec.yaml
+++ b/packages/camera/camera/pubspec.yaml
@@ -4,7 +4,7 @@
   Dart.
 repository: https://github.com/flutter/plugins/tree/main/packages/camera/camera
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
-version: 0.9.4+22
+version: 0.9.4+23
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/camera/camera_web/CHANGELOG.md b/packages/camera/camera_web/CHANGELOG.md
index 7a24e12..5a9fb66 100644
--- a/packages/camera/camera_web/CHANGELOG.md
+++ b/packages/camera/camera_web/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.2.1+6
+
+* Minor fixes for new analysis options.
+
 ## 0.2.1+5
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/camera/camera_web/example/integration_test/camera_test.dart b/packages/camera/camera_web/example/integration_test/camera_test.dart
index 20d1cba..50451b9 100644
--- a/packages/camera/camera_web/example/integration_test/camera_test.dart
+++ b/packages/camera/camera_web/example/integration_test/camera_test.dart
@@ -1477,7 +1477,7 @@
     });
 
     group('dispose', () {
-      testWidgets('resets the video element\'s source',
+      testWidgets("resets the video element's source",
           (WidgetTester tester) async {
         final Camera camera = Camera(
           textureId: textureId,
diff --git a/packages/camera/camera_web/example/integration_test/camera_web_test.dart b/packages/camera/camera_web/example/integration_test/camera_web_test.dart
index 5a564dd..143783f 100644
--- a/packages/camera/camera_web/example/integration_test/camera_web_test.dart
+++ b/packages/camera/camera_web/example/integration_test/camera_web_test.dart
@@ -498,7 +498,7 @@
               isA<CameraException>().having(
                 (CameraException e) => e.code,
                 'code',
-                exception.code.toString(),
+                exception.code,
               ),
             ),
           );
@@ -759,7 +759,7 @@
               isA<PlatformException>().having(
                 (PlatformException e) => e.code,
                 'code',
-                exception.name.toString(),
+                exception.name,
               ),
             ),
           );
@@ -2495,7 +2495,7 @@
             equals(
               CameraErrorEvent(
                 cameraId,
-                'Error code: ${CameraErrorCode.abort}, error message: The video element\'s source has not fully loaded.',
+                "Error code: ${CameraErrorCode.abort}, error message: The video element's source has not fully loaded.",
               ),
             ),
           );
diff --git a/packages/camera/camera_web/example/integration_test/helpers/mocks.dart b/packages/camera/camera_web/example/integration_test/helpers/mocks.dart
index 3d9550f..521c4bf 100644
--- a/packages/camera/camera_web/example/integration_test/helpers/mocks.dart
+++ b/packages/camera/camera_web/example/integration_test/helpers/mocks.dart
@@ -113,8 +113,8 @@
   final Stream<T> _stream;
 
   @override
-  StreamSubscription<T> listen(void onData(T event)?,
-      {Function? onError, void onDone()?, bool? cancelOnError}) {
+  StreamSubscription<T> listen(void Function(T event)? onData,
+      {Function? onError, void Function()? onDone, bool? cancelOnError}) {
     return _stream.listen(
       onData,
       onError: onError,
diff --git a/packages/camera/camera_web/lib/src/camera.dart b/packages/camera/camera_web/lib/src/camera.dart
index 71368c6..210a0df 100644
--- a/packages/camera/camera_web/lib/src/camera.dart
+++ b/packages/camera/camera_web/lib/src/camera.dart
@@ -138,6 +138,9 @@
 
   /// A builder to merge a list of blobs into a single blob.
   @visibleForTesting
+  // TODO(stuartmorgan): Remove this 'ignore' once we don't analyze using 2.10
+  // any more. It's a false positive that is fixed in later versions.
+  // ignore: prefer_function_declarations_over_variables
   html.Blob Function(List<html.Blob> blobs, String type) blobBuilder =
       (List<html.Blob> blobs, String type) => html.Blob(blobs, type);
 
diff --git a/packages/camera/camera_web/lib/src/camera_service.dart b/packages/camera/camera_web/lib/src/camera_service.dart
index f15845c..b118169 100644
--- a/packages/camera/camera_web/lib/src/camera_service.dart
+++ b/packages/camera/camera_web/lib/src/camera_service.dart
@@ -82,7 +82,7 @@
           throw CameraWebException(
             cameraId,
             CameraErrorCode.type,
-            'The camera options are incorrect or attempted'
+            'The camera options are incorrect or attempted '
             'to access the media input from an insecure context.',
           );
         case 'AbortError':
diff --git a/packages/camera/camera_web/lib/src/camera_web.dart b/packages/camera/camera_web/lib/src/camera_web.dart
index 6f9f10d..26f965d 100644
--- a/packages/camera/camera_web/lib/src/camera_web.dart
+++ b/packages/camera/camera_web/lib/src/camera_web.dart
@@ -290,7 +290,7 @@
         cameraEventStreamController.add(
           CameraErrorEvent(
             cameraId,
-            'Error code: ${CameraErrorCode.abort}, error message: The video element\'s source has not fully loaded.',
+            "Error code: ${CameraErrorCode.abort}, error message: The video element's source has not fully loaded.",
           ),
         );
       });
@@ -400,7 +400,7 @@
         // This wrapper allows use of both the old and new APIs.
         dynamic fullScreen() => documentElement.requestFullscreen();
         await fullScreen();
-        await screenOrientation.lock(orientationType.toString());
+        await screenOrientation.lock(orientationType);
       } else {
         throw PlatformException(
           code: CameraErrorCode.orientationNotSupported.toString(),
diff --git a/packages/camera/camera_web/pubspec.yaml b/packages/camera/camera_web/pubspec.yaml
index 8bef974..90d1195 100644
--- a/packages/camera/camera_web/pubspec.yaml
+++ b/packages/camera/camera_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin for getting information about and controlling the camera on Web.
 repository: https://github.com/flutter/plugins/tree/main/packages/camera/camera_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
-version: 0.2.1+5
+version: 0.2.1+6
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/file_selector/file_selector/CHANGELOG.md b/packages/file_selector/file_selector/CHANGELOG.md
index 17baf9f..6397833 100644
--- a/packages/file_selector/file_selector/CHANGELOG.md
+++ b/packages/file_selector/file_selector/CHANGELOG.md
@@ -1,3 +1,7 @@
+## NEXT
+
+* Minor fixes for new analysis options.
+
 ## 0.8.4+2
 
 * Removes unnecessary imports.
diff --git a/packages/file_selector/file_selector/test/file_selector_test.dart b/packages/file_selector/file_selector/test/file_selector_test.dart
index fc3e668..887ab64 100644
--- a/packages/file_selector/file_selector/test/file_selector_test.dart
+++ b/packages/file_selector/file_selector/test/file_selector_test.dart
@@ -284,10 +284,12 @@
     this.confirmButtonText = confirmButtonText;
   }
 
+  // ignore: use_setters_to_change_properties
   void setFileResponse(List<XFile> files) {
     this.files = files;
   }
 
+  // ignore: use_setters_to_change_properties
   void setPathResponse(String path) {
     this.path = path;
   }
diff --git a/packages/file_selector/file_selector_web/CHANGELOG.md b/packages/file_selector/file_selector_web/CHANGELOG.md
index ce9d559..3963601 100644
--- a/packages/file_selector/file_selector_web/CHANGELOG.md
+++ b/packages/file_selector/file_selector_web/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.8.1+5
+
+* Minor fixes for new analysis options.
+
 ## 0.8.1+4
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/file_selector/file_selector_web/example/integration_test/file_selector_web_test.dart b/packages/file_selector/file_selector_web/example/integration_test/file_selector_web_test.dart
index fe57d1d..43c88a2 100644
--- a/packages/file_selector/file_selector_web/example/integration_test/file_selector_web_test.dart
+++ b/packages/file_selector/file_selector_web/example/integration_test/file_selector_web_test.dart
@@ -19,10 +19,10 @@
       testWidgets('works', (WidgetTester _) async {
         final XFile mockFile = createXFile('1001', 'identity.png');
 
-        final MockDomHelper mockDomHelper = MockDomHelper()
-          ..setFiles(<XFile>[mockFile])
-          ..expectAccept('.jpg,.jpeg,image/png,image/*')
-          ..expectMultiple(false);
+        final MockDomHelper mockDomHelper = MockDomHelper(
+            files: <XFile>[mockFile],
+            expectAccept: '.jpg,.jpeg,image/png,image/*',
+            expectMultiple: false);
 
         final FileSelectorWeb plugin =
             FileSelectorWeb(domHelper: mockDomHelper);
@@ -49,10 +49,10 @@
         final XFile mockFile1 = createXFile('123456', 'file1.txt');
         final XFile mockFile2 = createXFile('', 'file2.txt');
 
-        final MockDomHelper mockDomHelper = MockDomHelper()
-          ..setFiles(<XFile>[mockFile1, mockFile2])
-          ..expectAccept('.txt')
-          ..expectMultiple(true);
+        final MockDomHelper mockDomHelper = MockDomHelper(
+            files: <XFile>[mockFile1, mockFile2],
+            expectAccept: '.txt',
+            expectMultiple: true);
 
         final FileSelectorWeb plugin =
             FileSelectorWeb(domHelper: mockDomHelper);
@@ -90,9 +90,17 @@
 }
 
 class MockDomHelper implements DomHelper {
-  List<XFile> _files = <XFile>[];
-  String _expectedAccept = '';
-  bool _expectedMultiple = false;
+  MockDomHelper({
+    List<XFile> files = const <XFile>[],
+    String expectAccept = '',
+    bool expectMultiple = false,
+  })  : _files = files,
+        _expectedAccept = expectAccept,
+        _expectedMultiple = expectMultiple;
+
+  final List<XFile> _files;
+  final String _expectedAccept;
+  final bool _expectedMultiple;
 
   @override
   Future<List<XFile>> getFiles({
@@ -106,18 +114,6 @@
         reason: 'Expected "multiple" value does not match.');
     return Future<List<XFile>>.value(_files);
   }
-
-  void setFiles(List<XFile> files) {
-    _files = files;
-  }
-
-  void expectAccept(String accept) {
-    _expectedAccept = accept;
-  }
-
-  void expectMultiple(bool multiple) {
-    _expectedMultiple = multiple;
-  }
 }
 
 XFile createXFile(String content, String name) {
diff --git a/packages/file_selector/file_selector_web/lib/src/utils.dart b/packages/file_selector/file_selector_web/lib/src/utils.dart
index 6a53464..fe8d1f4 100644
--- a/packages/file_selector/file_selector_web/lib/src/utils.dart
+++ b/packages/file_selector/file_selector_web/lib/src/utils.dart
@@ -36,5 +36,5 @@
 
 /// Append a dot at the beggining if it is not there png -> .png
 String _normalizeExtension(String ext) {
-  return ext.isNotEmpty && ext[0] != '.' ? '.' + ext : ext;
+  return ext.isNotEmpty && ext[0] != '.' ? '.$ext' : ext;
 }
diff --git a/packages/file_selector/file_selector_web/pubspec.yaml b/packages/file_selector/file_selector_web/pubspec.yaml
index 2e12b6d..4880319 100644
--- a/packages/file_selector/file_selector_web/pubspec.yaml
+++ b/packages/file_selector/file_selector_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of file_selector
 repository: https://github.com/flutter/plugins/tree/main/packages/file_selector/file_selector_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+file_selector%22
-version: 0.8.1+4
+version: 0.8.1+5
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md b/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md
index d1f2f92..07ffbfd 100644
--- a/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md
+++ b/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md
@@ -1,3 +1,7 @@
+## NEXT
+
+* Minor fixes for new analysis options.
+
 ## 2.1.5
 
 * Removes unnecessary imports.
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart
index 09df2b9..3975d64 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart
@@ -28,6 +28,7 @@
 class AnimateCameraState extends State<AnimateCamera> {
   GoogleMapController? mapController;
 
+  // ignore: use_setters_to_change_properties
   void _onMapCreated(GoogleMapController controller) {
     mapController = controller;
   }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart
index a6bae30..7fa8a03 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart
@@ -28,6 +28,7 @@
 class MoveCameraState extends State<MoveCamera> {
   GoogleMapController? mapController;
 
+  // ignore: use_setters_to_change_properties
   void _onMapCreated(GoogleMapController controller) {
     mapController = controller;
   }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart
index ef5033c..7cbb63a 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart
@@ -48,6 +48,7 @@
   int widthsIndex = 0;
   List<int> widths = <int>[10, 20, 5];
 
+  // ignore: use_setters_to_change_properties
   void _onMapCreated(GoogleMapController controller) {
     this.controller = controller;
   }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart
index 1238d61..b8efc4e 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart
@@ -43,6 +43,7 @@
   int _markerIdCounter = 1;
   LatLng? markerPosition;
 
+  // ignore: use_setters_to_change_properties
   void _onMapCreated(GoogleMapController controller) {
     this.controller = controller;
   }
@@ -207,7 +208,7 @@
 
   Future<void> _changeInfo(MarkerId markerId) async {
     final Marker marker = markers[markerId]!;
-    final String newSnippet = marker.infoWindow.snippet! + '*';
+    final String newSnippet = '${marker.infoWindow.snippet!}*';
     setState(() {
       markers[markerId] = marker.copyWith(
         infoWindowParam: marker.infoWindow.copyWith(
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart
index f193214..cb0cc56 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart
@@ -49,6 +49,7 @@
   int widthsIndex = 0;
   List<int> widths = <int>[10, 20, 5];
 
+  // ignore: use_setters_to_change_properties
   void _onMapCreated(GoogleMapController controller) {
     this.controller = controller;
   }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart
index b3a637c..7a7c5d2 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart
@@ -77,6 +77,7 @@
     <PatternItem>[PatternItem.dot, PatternItem.gap(10.0)],
   ];
 
+  // ignore: use_setters_to_change_properties
   void _onMapCreated(GoogleMapController controller) {
     this.controller = controller;
   }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart
index ca9d396..3d676e0 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart
@@ -66,7 +66,7 @@
             padding: const EdgeInsets.symmetric(vertical: 30.0),
             child: Column(
               children: <Widget>[
-                const Text('This map doesn\'t consume the vertical drags.'),
+                const Text("This map doesn't consume the vertical drags."),
                 const Padding(
                   padding: EdgeInsets.only(bottom: 12.0),
                   child:
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart
index 849a9f4..fbc7ae2 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart
@@ -68,6 +68,7 @@
     );
   }
 
+  // ignore: use_setters_to_change_properties
   void onMapCreated(GoogleMapController controller) {
     _mapController = controller;
   }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart
index 81dfc28..d88e099 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart
@@ -35,6 +35,7 @@
   GoogleMapController? controller;
   TileOverlay? _tileOverlay;
 
+  // ignore: use_setters_to_change_properties
   void _onMapCreated(GoogleMapController controller) {
     this.controller = controller;
   }
diff --git a/packages/google_sign_in/google_sign_in_web/CHANGELOG.md b/packages/google_sign_in/google_sign_in_web/CHANGELOG.md
index 6e87beb..9a6b076 100644
--- a/packages/google_sign_in/google_sign_in_web/CHANGELOG.md
+++ b/packages/google_sign_in/google_sign_in_web/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.10.1+2
+
+* Minor fixes for new analysis options.
+
 ## 0.10.1+1
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/google_sign_in/google_sign_in_web/example/integration_test/auth2_test.dart b/packages/google_sign_in/google_sign_in_web/example/integration_test/auth2_test.dart
index 9db0243..d8c7655 100644
--- a/packages/google_sign_in/google_sign_in_web/example/integration_test/auth2_test.dart
+++ b/packages/google_sign_in/google_sign_in_web/example/integration_test/auth2_test.dart
@@ -117,7 +117,7 @@
       expect(plugin.init(hostedDomain: ''), throwsAssertionError);
     });
 
-    testWidgets('Init doesn\'t accept spaces in scopes',
+    testWidgets("Init doesn't accept spaces in scopes",
         (WidgetTester tester) async {
       expect(
           plugin.init(
diff --git a/packages/google_sign_in/google_sign_in_web/example/integration_test/gapi_utils_test.dart b/packages/google_sign_in/google_sign_in_web/example/integration_test/gapi_utils_test.dart
index 1447093..b341d1d 100644
--- a/packages/google_sign_in/google_sign_in_web/example/integration_test/gapi_utils_test.dart
+++ b/packages/google_sign_in/google_sign_in_web/example/integration_test/gapi_utils_test.dart
@@ -51,10 +51,12 @@
   @override
   gapi.BasicProfile? getBasicProfile() => _basicProfile;
 
+  // ignore: use_setters_to_change_properties
   void setIsSignedIn(bool isSignedIn) {
     _isSignedIn = isSignedIn;
   }
 
+  // ignore: use_setters_to_change_properties
   void setBasicProfile(gapi.BasicProfile basicProfile) {
     _basicProfile = basicProfile;
   }
diff --git a/packages/google_sign_in/google_sign_in_web/example/integration_test/src/test_utils.dart b/packages/google_sign_in/google_sign_in_web/example/integration_test/src/test_utils.dart
index 89f9b55..56aa61d 100644
--- a/packages/google_sign_in/google_sign_in_web/example/integration_test/src/test_utils.dart
+++ b/packages/google_sign_in/google_sign_in_web/example/integration_test/src/test_utils.dart
@@ -6,5 +6,5 @@
 
 String toBase64Url(String contents) {
   // Open the file
-  return 'data:text/javascript;base64,' + base64.encode(utf8.encode(contents));
+  return 'data:text/javascript;base64,${base64.encode(utf8.encode(contents))}';
 }
diff --git a/packages/google_sign_in/google_sign_in_web/lib/google_sign_in_web.dart b/packages/google_sign_in/google_sign_in_web/lib/google_sign_in_web.dart
index 533c353..ae6180d 100644
--- a/packages/google_sign_in/google_sign_in_web/lib/google_sign_in_web.dart
+++ b/packages/google_sign_in/google_sign_in_web/lib/google_sign_in_web.dart
@@ -81,7 +81,7 @@
 
     assert(
         !scopes.any((String scope) => scope.contains(' ')),
-        'OAuth 2.0 Scopes for Google APIs can\'t contain spaces.'
+        "OAuth 2.0 Scopes for Google APIs can't contain spaces. "
         'Check https://developers.google.com/identity/protocols/googlescopes '
         'for a list of valid OAuth 2.0 scopes.');
 
diff --git a/packages/google_sign_in/google_sign_in_web/lib/src/generated/gapiauth2.dart b/packages/google_sign_in/google_sign_in_web/lib/src/generated/gapiauth2.dart
index 8e23713..e172166 100644
--- a/packages/google_sign_in/google_sign_in_web/lib/src/generated/gapiauth2.dart
+++ b/packages/google_sign_in/google_sign_in_web/lib/src/generated/gapiauth2.dart
@@ -57,8 +57,8 @@
 
   /// Calls the onInit function when the GoogleAuth object is fully initialized, or calls the onFailure function if
   /// initialization fails.
-  external dynamic then(dynamic onInit(GoogleAuth googleAuth),
-      [dynamic onFailure(GoogleAuthInitFailureError reason)]);
+  external dynamic then(dynamic Function(GoogleAuth googleAuth) onInit,
+      [dynamic Function(GoogleAuthInitFailureError reason) onFailure]);
 
   /// Signs out all accounts from the application.
   external dynamic signOut();
@@ -70,8 +70,8 @@
   external dynamic attachClickHandler(
       dynamic container,
       SigninOptions options,
-      dynamic onsuccess(GoogleUser googleUser),
-      dynamic onfailure(String reason));
+      dynamic Function(GoogleUser googleUser) onsuccess,
+      dynamic Function(String reason) onfailure);
 }
 
 @anonymous
@@ -104,7 +104,7 @@
   external bool get();
 
   /// Listen for changes in the current user's sign-in state.
-  external void listen(dynamic listener(bool signedIn));
+  external void listen(dynamic Function(bool signedIn) listener);
 }
 
 @anonymous
@@ -116,7 +116,7 @@
   external GoogleUser get();
 
   /// Listen for changes in currentUser.
-  external void listen(dynamic listener(GoogleUser user));
+  external void listen(dynamic Function(GoogleUser user) listener);
 }
 
 @anonymous
@@ -440,7 +440,7 @@
 /// Reference: https://developers.google.com/api-client-library/javascript/reference/referencedocs#gapiauth2authorizeparams-callback
 @JS('gapi.auth2.authorize')
 external void authorize(
-    AuthorizeConfig params, void callback(AuthorizeResponse response));
+    AuthorizeConfig params, void Function(AuthorizeResponse response) callback);
 // End module gapi.auth2
 
 // Module gapi.signin2
@@ -497,6 +497,7 @@
 @JS()
 abstract class Promise<T> {
   external factory Promise(
-      void executor(void resolve(T result), Function reject));
-  external Promise then(void onFulfilled(T result), [Function onRejected]);
+      void Function(void Function(T result) resolve, Function reject) executor);
+  external Promise then(void Function(T result) onFulfilled,
+      [Function onRejected]);
 }
diff --git a/packages/google_sign_in/google_sign_in_web/lib/src/utils.dart b/packages/google_sign_in/google_sign_in_web/lib/src/utils.dart
index cae20d2..72424d8 100644
--- a/packages/google_sign_in/google_sign_in_web/lib/src/utils.dart
+++ b/packages/google_sign_in/google_sign_in_web/lib/src/utils.dart
@@ -29,6 +29,7 @@
     final html.ScriptElement script = html.ScriptElement()
       ..async = true
       ..defer = true
+      // ignore: unsafe_html
       ..src = library;
     // TODO(ditman): add a timeout race to fail this future
     loading.add(script.onLoad.first);
diff --git a/packages/google_sign_in/google_sign_in_web/pubspec.yaml b/packages/google_sign_in/google_sign_in_web/pubspec.yaml
index 3dcd0e8..a270af9 100644
--- a/packages/google_sign_in/google_sign_in_web/pubspec.yaml
+++ b/packages/google_sign_in/google_sign_in_web/pubspec.yaml
@@ -3,7 +3,7 @@
   for signing in with a Google account on Android, iOS and Web.
 repository: https://github.com/flutter/plugins/tree/main/packages/google_sign_in/google_sign_in_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+google_sign_in%22
-version: 0.10.1+1
+version: 0.10.1+2
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/image_picker/image_picker/CHANGELOG.md b/packages/image_picker/image_picker/CHANGELOG.md
index a384a52..156b9a3 100644
--- a/packages/image_picker/image_picker/CHANGELOG.md
+++ b/packages/image_picker/image_picker/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.8.5+2
+
+* Minor fixes for new analysis options.
+
 ## 0.8.5+1
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/image_picker/image_picker/example/lib/main.dart b/packages/image_picker/image_picker/example/lib/main.dart
index a6f0e83..4eecc5f 100755
--- a/packages/image_picker/image_picker/example/lib/main.dart
+++ b/packages/image_picker/image_picker/example/lib/main.dart
@@ -40,7 +40,7 @@
 class _MyHomePageState extends State<MyHomePage> {
   List<XFile>? _imageFileList;
 
-  set _imageFile(XFile? value) {
+  void _setImageFileListFromFile(XFile? value) {
     _imageFileList = value == null ? null : <XFile>[value];
   }
 
@@ -118,7 +118,7 @@
             imageQuality: quality,
           );
           setState(() {
-            _imageFile = pickedFile;
+            _setImageFileListFromFile(pickedFile);
           });
         } catch (e) {
           setState(() {
@@ -228,8 +228,11 @@
       } else {
         isVideo = false;
         setState(() {
-          _imageFile = response.file;
-          _imageFileList = response.files;
+          if (response.files == null) {
+            _setImageFileListFromFile(response.file);
+          } else {
+            _imageFileList = response.files;
+          }
         });
       }
     } else {
diff --git a/packages/image_picker/image_picker/pubspec.yaml b/packages/image_picker/image_picker/pubspec.yaml
index 818486d..cc34d8a 100755
--- a/packages/image_picker/image_picker/pubspec.yaml
+++ b/packages/image_picker/image_picker/pubspec.yaml
@@ -3,7 +3,7 @@
   library, and taking new pictures with the camera.
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.8.5+1
+version: 0.8.5+2
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_android/CHANGELOG.md b/packages/image_picker/image_picker_android/CHANGELOG.md
index 0514fc3..eede634 100644
--- a/packages/image_picker/image_picker_android/CHANGELOG.md
+++ b/packages/image_picker/image_picker_android/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.8.4+13
+
+* Minor fixes for new analysis options.
+
 ## 0.8.4+12
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/image_picker/image_picker_android/example/lib/main.dart b/packages/image_picker/image_picker_android/example/lib/main.dart
index d56aeb8..212e064 100755
--- a/packages/image_picker/image_picker_android/example/lib/main.dart
+++ b/packages/image_picker/image_picker_android/example/lib/main.dart
@@ -40,7 +40,7 @@
 class _MyHomePageState extends State<MyHomePage> {
   List<XFile>? _imageFileList;
 
-  set _imageFile(XFile? value) {
+  void _setImageFileListFromFile(XFile? value) {
     _imageFileList = value == null ? null : <XFile>[value];
   }
 
@@ -118,7 +118,7 @@
             imageQuality: quality,
           );
           setState(() {
-            _imageFile = pickedFile;
+            _setImageFileListFromFile(pickedFile);
           });
         } catch (e) {
           setState(() {
@@ -228,8 +228,11 @@
       } else {
         isVideo = false;
         setState(() {
-          _imageFile = response.file;
-          _imageFileList = response.files;
+          if (response.files == null) {
+            _setImageFileListFromFile(response.file);
+          } else {
+            _imageFileList = response.files;
+          }
         });
       }
     } else {
diff --git a/packages/image_picker/image_picker_android/pubspec.yaml b/packages/image_picker/image_picker_android/pubspec.yaml
index 90d136c..0955346 100755
--- a/packages/image_picker/image_picker_android/pubspec.yaml
+++ b/packages/image_picker/image_picker_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the image_picker plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.8.4+12
+version: 0.8.4+13
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_for_web/CHANGELOG.md b/packages/image_picker/image_picker_for_web/CHANGELOG.md
index c33b3b9..b69ba59 100644
--- a/packages/image_picker/image_picker_for_web/CHANGELOG.md
+++ b/packages/image_picker/image_picker_for_web/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 2.1.8
+
+* Minor fixes for new analysis options.
+
 ## 2.1.7
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/image_picker/image_picker_for_web/example/integration_test/image_resizer_test.dart b/packages/image_picker/image_picker_for_web/example/integration_test/image_resizer_test.dart
index 91794a7..1efd7b2 100644
--- a/packages/image_picker/image_picker_for_web/example/integration_test/image_resizer_test.dart
+++ b/packages/image_picker/image_picker_for_web/example/integration_test/image_resizer_test.dart
@@ -33,8 +33,8 @@
   testWidgets('image is loaded correctly ', (WidgetTester tester) async {
     final html.ImageElement imageElement =
         await imageResizer.loadImage(pngFile.path);
-    expect(imageElement.width!, 10);
-    expect(imageElement.height!, 10);
+    expect(imageElement.width, 10);
+    expect(imageElement.height, 10);
   });
 
   testWidgets(
diff --git a/packages/image_picker/image_picker_for_web/lib/src/image_resizer.dart b/packages/image_picker/image_picker_for_web/lib/src/image_resizer.dart
index e063099..ba794ac 100644
--- a/packages/image_picker/image_picker_for_web/lib/src/image_resizer.dart
+++ b/packages/image_picker/image_picker_for_web/lib/src/image_resizer.dart
@@ -39,6 +39,7 @@
     final Completer<html.ImageElement> imageLoadCompleter =
         Completer<html.ImageElement>();
     final html.ImageElement imageElement = html.ImageElement();
+    // ignore: unsafe_html
     imageElement.src = blobUrl;
 
     imageElement.onLoad.listen((html.Event event) {
@@ -81,7 +82,7 @@
         await canvas.toBlob(originalFile.mimeType, calculatedImageQuality);
     return XFile(html.Url.createObjectUrlFromBlob(blob),
         mimeType: originalFile.mimeType,
-        name: 'scaled_' + originalFile.name,
+        name: 'scaled_${originalFile.name}',
         lastModified: DateTime.now(),
         length: blob.size);
   }
diff --git a/packages/image_picker/image_picker_for_web/pubspec.yaml b/packages/image_picker/image_picker_for_web/pubspec.yaml
index b0c5deb..0b2c6d2 100644
--- a/packages/image_picker/image_picker_for_web/pubspec.yaml
+++ b/packages/image_picker/image_picker_for_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of image_picker
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_for_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 2.1.7
+version: 2.1.8
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_ios/CHANGELOG.md b/packages/image_picker/image_picker_ios/CHANGELOG.md
index af391db..96b1c7f 100644
--- a/packages/image_picker/image_picker_ios/CHANGELOG.md
+++ b/packages/image_picker/image_picker_ios/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.8.5+2
+
+* Minor fixes for new analysis options.
+
 ## 0.8.5+1
 
 * Removes unnecessary imports.
diff --git a/packages/image_picker/image_picker_ios/example/lib/main.dart b/packages/image_picker/image_picker_ios/example/lib/main.dart
index d56aeb8..c5372b8 100755
--- a/packages/image_picker/image_picker_ios/example/lib/main.dart
+++ b/packages/image_picker/image_picker_ios/example/lib/main.dart
@@ -40,7 +40,7 @@
 class _MyHomePageState extends State<MyHomePage> {
   List<XFile>? _imageFileList;
 
-  set _imageFile(XFile? value) {
+  void _setImageFileListFromFile(XFile? value) {
     _imageFileList = value == null ? null : <XFile>[value];
   }
 
@@ -118,7 +118,7 @@
             imageQuality: quality,
           );
           setState(() {
-            _imageFile = pickedFile;
+            _setImageFileListFromFile(pickedFile);
           });
         } catch (e) {
           setState(() {
@@ -216,27 +216,6 @@
     }
   }
 
-  Future<void> retrieveLostData() async {
-    final LostDataResponse response = await _picker.getLostData();
-    if (response.isEmpty) {
-      return;
-    }
-    if (response.file != null) {
-      if (response.type == RetrieveType.video) {
-        isVideo = true;
-        await _playVideo(response.file);
-      } else {
-        isVideo = false;
-        setState(() {
-          _imageFile = response.file;
-          _imageFileList = response.files;
-        });
-      }
-    } else {
-      _retrieveDataError = response.exception!.code;
-    }
-  }
-
   @override
   Widget build(BuildContext context) {
     return Scaffold(
@@ -244,35 +223,7 @@
         title: Text(widget.title!),
       ),
       body: Center(
-        child: !kIsWeb && defaultTargetPlatform == TargetPlatform.android
-            ? FutureBuilder<void>(
-                future: retrieveLostData(),
-                builder: (BuildContext context, AsyncSnapshot<void> snapshot) {
-                  switch (snapshot.connectionState) {
-                    case ConnectionState.none:
-                    case ConnectionState.waiting:
-                      return const Text(
-                        'You have not yet picked an image.',
-                        textAlign: TextAlign.center,
-                      );
-                    case ConnectionState.done:
-                      return _handlePreview();
-                    default:
-                      if (snapshot.hasError) {
-                        return Text(
-                          'Pick image/video error: ${snapshot.error}}',
-                          textAlign: TextAlign.center,
-                        );
-                      } else {
-                        return const Text(
-                          'You have not yet picked an image.',
-                          textAlign: TextAlign.center,
-                        );
-                      }
-                  }
-                },
-              )
-            : _handlePreview(),
+        child: _handlePreview(),
       ),
       floatingActionButton: Column(
         mainAxisAlignment: MainAxisAlignment.end,
diff --git a/packages/image_picker/image_picker_ios/pubspec.yaml b/packages/image_picker/image_picker_ios/pubspec.yaml
index 76ca206..d1de0a1 100755
--- a/packages/image_picker/image_picker_ios/pubspec.yaml
+++ b/packages/image_picker/image_picker_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the video_picker plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.8.5+1
+version: 0.8.5+2
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_platform_interface/CHANGELOG.md b/packages/image_picker/image_picker_platform_interface/CHANGELOG.md
index 9f6d174..2defdd2 100644
--- a/packages/image_picker/image_picker_platform_interface/CHANGELOG.md
+++ b/packages/image_picker/image_picker_platform_interface/CHANGELOG.md
@@ -1,3 +1,7 @@
+## NEXT
+
+* Minor fixes for new analysis options.
+
 ## 2.4.4
 
 * Internal code cleanup for stricter analysis options.
diff --git a/packages/image_picker/image_picker_platform_interface/test/picked_file_io_test.dart b/packages/image_picker/image_picker_platform_interface/test/picked_file_io_test.dart
index 3201d3a..3e6cd0e 100644
--- a/packages/image_picker/image_picker_platform_interface/test/picked_file_io_test.dart
+++ b/packages/image_picker/image_picker_platform_interface/test/picked_file_io_test.dart
@@ -13,7 +13,7 @@
 
 final String pathPrefix =
     Directory.current.path.endsWith('test') ? './assets/' : './test/assets/';
-final String path = pathPrefix + 'hello.txt';
+final String path = '${pathPrefix}hello.txt';
 const String expectedStringContents = 'Hello, world!';
 final Uint8List bytes = Uint8List.fromList(utf8.encode(expectedStringContents));
 final File textFile = File(path);
diff --git a/packages/image_picker/image_picker_windows/CHANGELOG.md b/packages/image_picker/image_picker_windows/CHANGELOG.md
index e72ab24..b8a2655 100644
--- a/packages/image_picker/image_picker_windows/CHANGELOG.md
+++ b/packages/image_picker/image_picker_windows/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.1.0+2
+
+* Minor fixes for new analysis options.
+
 ## 0.1.0+1
 
 * Removes unnecessary imports.
diff --git a/packages/image_picker/image_picker_windows/example/lib/main.dart b/packages/image_picker/image_picker_windows/example/lib/main.dart
index b3ba357..e340a18 100644
--- a/packages/image_picker/image_picker_windows/example/lib/main.dart
+++ b/packages/image_picker/image_picker_windows/example/lib/main.dart
@@ -40,7 +40,7 @@
   List<PickedFile>? _imageFileList;
 
   // This must be called from within a setState() callback
-  set _imageFile(PickedFile? value) {
+  void _setImageFileListFromFile(PickedFile? value) {
     _imageFileList = value == null ? null : <PickedFile>[value];
   }
 
@@ -102,7 +102,7 @@
           imageQuality: quality,
         );
         setState(() {
-          _imageFile = pickedFile;
+          _setImageFileListFromFile(pickedFile);
         });
       } catch (e) {
         setState(() {
diff --git a/packages/image_picker/image_picker_windows/lib/image_picker_windows.dart b/packages/image_picker/image_picker_windows/lib/image_picker_windows.dart
index 9bd26c4..0c6d6fb 100644
--- a/packages/image_picker/image_picker_windows/lib/image_picker_windows.dart
+++ b/packages/image_picker/image_picker_windows/lib/image_picker_windows.dart
@@ -46,7 +46,7 @@
 
   /// The file selector used to prompt the user to select images or videos.
   @visibleForTesting
-  static late FileSelectorPlatform fileSelector = FileSelectorWindows();
+  static FileSelectorPlatform fileSelector = FileSelectorWindows();
 
   /// Registers this class as the default instance of [ImagePickerPlatform].
   static void registerWith() {
diff --git a/packages/image_picker/image_picker_windows/pubspec.yaml b/packages/image_picker/image_picker_windows/pubspec.yaml
index afadf3e..af96030 100644
--- a/packages/image_picker/image_picker_windows/pubspec.yaml
+++ b/packages/image_picker/image_picker_windows/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Windows platform implementation of image_picker
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_windows
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.1.0+1
+version: 0.1.0+2
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/in_app_purchase/in_app_purchase/CHANGELOG.md b/packages/in_app_purchase/in_app_purchase/CHANGELOG.md
index 8412c23..6f0d487 100644
--- a/packages/in_app_purchase/in_app_purchase/CHANGELOG.md
+++ b/packages/in_app_purchase/in_app_purchase/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 3.0.4
+
+* Minor fixes for new analysis options.
+
 ## 3.0.3
 
 * Removes unnecessary imports.
diff --git a/packages/in_app_purchase/in_app_purchase/example/lib/main.dart b/packages/in_app_purchase/in_app_purchase/example/lib/main.dart
index 34346a0..5dbdd8c 100644
--- a/packages/in_app_purchase/in_app_purchase/example/lib/main.dart
+++ b/packages/in_app_purchase/in_app_purchase/example/lib/main.dart
@@ -193,8 +193,8 @@
     final Widget storeHeader = ListTile(
       leading: Icon(_isAvailable ? Icons.check : Icons.block,
           color: _isAvailable ? Colors.green : ThemeData.light().errorColor),
-      title: Text(
-          'The store is ' + (_isAvailable ? 'available' : 'unavailable') + '.'),
+      title:
+          Text('The store is ${_isAvailable ? 'available' : 'unavailable'}.'),
     );
     final List<Widget> children = <Widget>[storeHeader];
 
diff --git a/packages/in_app_purchase/in_app_purchase/pubspec.yaml b/packages/in_app_purchase/in_app_purchase/pubspec.yaml
index d2f8752..4b9b9b7 100644
--- a/packages/in_app_purchase/in_app_purchase/pubspec.yaml
+++ b/packages/in_app_purchase/in_app_purchase/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin for in-app purchases. Exposes APIs for making in-app purchases through the App Store and Google Play.
 repository: https://github.com/flutter/plugins/tree/main/packages/in_app_purchase/in_app_purchase
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 3.0.3
+version: 3.0.4
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md b/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md
index 4b9e58c..18284f2 100644
--- a/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md
+++ b/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.2.2+5
+
+* Minor fixes for new analysis options.
+
 ## 0.2.2+4
 
 * Removes unnecessary imports.
diff --git a/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart b/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart
index 1da9435..b1d90d4 100644
--- a/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart
+++ b/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart
@@ -187,8 +187,8 @@
     final Widget storeHeader = ListTile(
       leading: Icon(_isAvailable ? Icons.check : Icons.block,
           color: _isAvailable ? Colors.green : ThemeData.light().errorColor),
-      title: Text(
-          'The store is ' + (_isAvailable ? 'available' : 'unavailable') + '.'),
+      title:
+          Text('The store is ${_isAvailable ? 'available' : 'unavailable'}.'),
     );
     final List<Widget> children = <Widget>[storeHeader];
 
diff --git a/packages/in_app_purchase/in_app_purchase_android/lib/src/billing_client_wrappers/billing_client_wrapper.dart b/packages/in_app_purchase/in_app_purchase_android/lib/src/billing_client_wrappers/billing_client_wrapper.dart
index 7378aeb..70343fc 100644
--- a/packages/in_app_purchase/in_app_purchase_android/lib/src/billing_client_wrappers/billing_client_wrapper.dart
+++ b/packages/in_app_purchase/in_app_purchase_android/lib/src/billing_client_wrappers/billing_client_wrapper.dart
@@ -84,7 +84,9 @@
   /// **Deprecation warning:** it is no longer required to call
   /// [enablePendingPurchases] when initializing your application.
   @Deprecated(
-      'The requirement to call `enablePendingPurchases()` has become obsolete since Google Play no longer accepts app submissions that don\'t support pending purchases.')
+      'The requirement to call `enablePendingPurchases()` has become obsolete '
+      "since Google Play no longer accepts app submissions that don't support "
+      'pending purchases.')
   void enablePendingPurchases() {
     // No-op, until it is time to completely remove this method from the API.
   }
diff --git a/packages/in_app_purchase/in_app_purchase_android/lib/src/in_app_purchase_android_platform_addition.dart b/packages/in_app_purchase/in_app_purchase_android/lib/src/in_app_purchase_android_platform_addition.dart
index dd62916..db53ff4 100644
--- a/packages/in_app_purchase/in_app_purchase_android/lib/src/in_app_purchase_android_platform_addition.dart
+++ b/packages/in_app_purchase/in_app_purchase_android/lib/src/in_app_purchase_android_platform_addition.dart
@@ -25,7 +25,9 @@
   // ignore: deprecated_member_use_from_same_package
   /// See also [enablePendingPurchases] for more on pending purchases.
   @Deprecated(
-      'The requirement to call `enablePendingPurchases()` has become obsolete since Google Play no longer accepts app submissions that don\'t support pending purchases.')
+      'The requirement to call `enablePendingPurchases()` has become obsolete '
+      "since Google Play no longer accepts app submissions that don't support "
+      'pending purchases.')
   static bool get enablePendingPurchase => true;
 
   /// Enable the [InAppPurchaseConnection] to handle pending purchases.
@@ -33,7 +35,9 @@
   /// **Deprecation warning:** it is no longer required to call
   /// [enablePendingPurchases] when initializing your application.
   @Deprecated(
-      'The requirement to call `enablePendingPurchases()` has become obsolete since Google Play no longer accepts app submissions that don\'t support pending purchases.')
+      'The requirement to call `enablePendingPurchases()` has become obsolete '
+      "since Google Play no longer accepts app submissions that don't support "
+      'pending purchases.')
   static void enablePendingPurchases() {
     // No-op, until it is time to completely remove this method from the API.
   }
diff --git a/packages/in_app_purchase/in_app_purchase_android/lib/src/types/google_play_product_details.dart b/packages/in_app_purchase/in_app_purchase_android/lib/src/types/google_play_product_details.dart
index 58fd34e..15ed16c 100644
--- a/packages/in_app_purchase/in_app_purchase_android/lib/src/types/google_play_product_details.dart
+++ b/packages/in_app_purchase/in_app_purchase_android/lib/src/types/google_play_product_details.dart
@@ -39,7 +39,7 @@
       title: skuDetails.title,
       description: skuDetails.description,
       price: skuDetails.price,
-      rawPrice: ((skuDetails.priceAmountMicros) / 1000000.0).toDouble(),
+      rawPrice: skuDetails.priceAmountMicros / 1000000.0,
       currencyCode: skuDetails.priceCurrencyCode,
       currencySymbol: skuDetails.priceCurrencySymbol,
       skuDetails: skuDetails,
diff --git a/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml b/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml
index 7de7781..1032519 100644
--- a/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml
+++ b/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: An implementation for the Android platform of the Flutter `in_app_purchase` plugin. This uses the Android BillingClient APIs.
 repository: https://github.com/flutter/plugins/tree/main/packages/in_app_purchase/in_app_purchase_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 0.2.2+4
+version: 0.2.2+5
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md b/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md
index 7342077..aba1d6e 100644
--- a/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md
+++ b/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.3.0+7
+
+* Minor fixes for new analysis options.
+
 ## 0.3.0+6
 
 * Removes unnecessary imports.
diff --git a/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart b/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart
index f45a8c7..5ebf1b0 100644
--- a/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart
+++ b/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart
@@ -192,8 +192,8 @@
     final Widget storeHeader = ListTile(
       leading: Icon(_isAvailable ? Icons.check : Icons.block,
           color: _isAvailable ? Colors.green : ThemeData.light().errorColor),
-      title: Text(
-          'The store is ' + (_isAvailable ? 'available' : 'unavailable') + '.'),
+      title:
+          Text('The store is ${_isAvailable ? 'available' : 'unavailable'}.'),
     );
     final List<Widget> children = <Widget>[storeHeader];
 
diff --git a/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml b/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml
index 24b693c..235d491 100644
--- a/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml
+++ b/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml
@@ -2,7 +2,7 @@
 description: An implementation for the iOS platform of the Flutter `in_app_purchase` plugin. This uses the StoreKit Framework.
 repository: https://github.com/flutter/plugins/tree/main/packages/in_app_purchase/in_app_purchase_storekit
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 0.3.0+6
+version: 0.3.0+7
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/in_app_purchase/in_app_purchase_storekit/test/store_kit_wrappers/sk_product_test.dart b/packages/in_app_purchase/in_app_purchase_storekit/test/store_kit_wrappers/sk_product_test.dart
index 4132933..12fb214 100644
--- a/packages/in_app_purchase/in_app_purchase_storekit/test/store_kit_wrappers/sk_product_test.dart
+++ b/packages/in_app_purchase/in_app_purchase_storekit/test/store_kit_wrappers/sk_product_test.dart
@@ -16,7 +16,7 @@
         () {
       final SKProductSubscriptionPeriodWrapper wrapper =
           SKProductSubscriptionPeriodWrapper.fromJson(
-              buildSubscriptionPeriodMap(dummySubscription)!);
+              buildSubscriptionPeriodMap(dummySubscription));
       expect(wrapper, equals(dummySubscription));
     });
 
@@ -95,8 +95,7 @@
       expect(product.title, wrapper.localizedTitle);
       expect(product.description, wrapper.localizedDescription);
       expect(product.id, wrapper.productIdentifier);
-      expect(product.price,
-          wrapper.priceLocale.currencySymbol + wrapper.price.toString());
+      expect(product.price, wrapper.priceLocale.currencySymbol + wrapper.price);
       expect(product.skProduct, wrapper);
     });
 
diff --git a/packages/local_auth/local_auth_android/CHANGELOG.md b/packages/local_auth/local_auth_android/CHANGELOG.md
index 9f9bd7b..f18e76b 100644
--- a/packages/local_auth/local_auth_android/CHANGELOG.md
+++ b/packages/local_auth/local_auth_android/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 1.0.4
+
+* Minor fixes for new analysis options.
+
 ## 1.0.3
 
 * Removes unnecessary imports.
diff --git a/packages/local_auth/local_auth_android/lib/types/auth_messages_android.dart b/packages/local_auth/local_auth_android/lib/types/auth_messages_android.dart
index ad90124..c82f682 100644
--- a/packages/local_auth/local_auth_android/lib/types/auth_messages_android.dart
+++ b/packages/local_auth/local_auth_android/lib/types/auth_messages_android.dart
@@ -187,6 +187,6 @@
 /// biometric on their device.
 String get androidGoToSettingsDescription => Intl.message(
     'Biometric authentication is not set up on your device. Go to '
-    '\'Settings > Security\' to add biometric authentication.',
+    "'Settings > Security' to add biometric authentication.",
     desc: 'Message advising the user to go to the settings and configure '
         'biometric on their device.');
diff --git a/packages/local_auth/local_auth_android/pubspec.yaml b/packages/local_auth/local_auth_android/pubspec.yaml
index cdd4e82..0feea23 100644
--- a/packages/local_auth/local_auth_android/pubspec.yaml
+++ b/packages/local_auth/local_auth_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the local_auth plugin.
 repository: https://github.com/flutter/plugins/tree/master/packages/local_auth/local_auth_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+local_auth%22
-version: 1.0.3
+version: 1.0.4
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/path_provider/path_provider_platform_interface/CHANGELOG.md b/packages/path_provider/path_provider_platform_interface/CHANGELOG.md
index 4ed22f0..4eea4b3 100644
--- a/packages/path_provider/path_provider_platform_interface/CHANGELOG.md
+++ b/packages/path_provider/path_provider_platform_interface/CHANGELOG.md
@@ -1,5 +1,6 @@
-## NEXT
+## 2.0.4
 
+* Minor fixes for new analysis options.
 * Removes unnecessary imports.
 
 ## 2.0.3
diff --git a/packages/path_provider/path_provider_platform_interface/lib/src/method_channel_path_provider.dart b/packages/path_provider/path_provider_platform_interface/lib/src/method_channel_path_provider.dart
index 73e6ab4..fe63274 100644
--- a/packages/path_provider/path_provider_platform_interface/lib/src/method_channel_path_provider.dart
+++ b/packages/path_provider/path_provider_platform_interface/lib/src/method_channel_path_provider.dart
@@ -22,6 +22,7 @@
   /// This API is only exposed for the unit tests. It should not be used by
   /// any code outside of the plugin itself.
   @visibleForTesting
+  // ignore: use_setters_to_change_properties
   void setMockPathProviderPlatform(Platform platform) {
     _platform = platform;
   }
diff --git a/packages/path_provider/path_provider_platform_interface/pubspec.yaml b/packages/path_provider/path_provider_platform_interface/pubspec.yaml
index d1b0b38..90b40ac 100644
--- a/packages/path_provider/path_provider_platform_interface/pubspec.yaml
+++ b/packages/path_provider/path_provider_platform_interface/pubspec.yaml
@@ -4,7 +4,7 @@
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+path_provider%22
 # NOTE: We strongly prefer non-breaking changes, even at the expense of a
 # less-clean API. See https://flutter.dev/go/platform-interface-breaking-changes
-version: 2.0.3
+version: 2.0.4
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/path_provider/path_provider_windows/CHANGELOG.md b/packages/path_provider/path_provider_windows/CHANGELOG.md
index 014b6b3..d933b0d 100644
--- a/packages/path_provider/path_provider_windows/CHANGELOG.md
+++ b/packages/path_provider/path_provider_windows/CHANGELOG.md
@@ -1,3 +1,7 @@
+## NEXT
+
+* Minor fixes for new analysis options.
+
 ## 2.0.6
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/path_provider/path_provider_windows/test/path_provider_windows_test.dart b/packages/path_provider/path_provider_windows/test/path_provider_windows_test.dart
index e977e07..7e4118c 100644
--- a/packages/path_provider/path_provider_windows/test/path_provider_windows_test.dart
+++ b/packages/path_provider/path_provider_windows/test/path_provider_windows_test.dart
@@ -78,9 +78,8 @@
     if (path != null) {
       expect(
           path,
-          endsWith(r'AppData\Roaming\'
-              r'A _Bad_ Company_ Name\'
-              r'A__Terrible__App__Name'));
+          endsWith(
+              r'AppData\Roaming\A _Bad_ Company_ Name\A__Terrible__App__Name'));
       expect(Directory(path).existsSync(), isTrue);
     }
   }, skip: !Platform.isWindows);
diff --git a/packages/plugin_platform_interface/CHANGELOG.md b/packages/plugin_platform_interface/CHANGELOG.md
index 72229cb..0e9b701 100644
--- a/packages/plugin_platform_interface/CHANGELOG.md
+++ b/packages/plugin_platform_interface/CHANGELOG.md
@@ -1,5 +1,6 @@
 ## NEXT
 
+* Minor fixes for new analysis options.
 * Adds additional tests for `PlatformInterface` and `MockPlatformInterfaceMixin`.
 
 ## 2.1.2
diff --git a/packages/plugin_platform_interface/test/plugin_platform_interface_test.dart b/packages/plugin_platform_interface/test/plugin_platform_interface_test.dart
index 9e1ddc0..329cecb 100644
--- a/packages/plugin_platform_interface/test/plugin_platform_interface_test.dart
+++ b/packages/plugin_platform_interface/test/plugin_platform_interface_test.dart
@@ -11,6 +11,7 @@
 
   static final Object _token = Object();
 
+  // ignore: avoid_setters_without_getters
   static set instance(SamplePluginPlatform instance) {
     PlatformInterface.verify(instance, _token);
     // A real implementation would set a static instance field here.
@@ -35,6 +36,7 @@
 
   static const Object _token = Object(); // invalid
 
+  // ignore: avoid_setters_without_getters
   static set instance(ConstTokenPluginPlatform instance) {
     PlatformInterface.verify(instance, _token);
   }
@@ -47,6 +49,7 @@
 
   static final Object _token = Object();
 
+  // ignore: avoid_setters_without_getters
   static set instance(VerifyTokenPluginPlatform instance) {
     PlatformInterface.verifyToken(instance, _token);
     // A real implementation would set a static instance field here.
@@ -68,6 +71,7 @@
 
   static const Object _token = Object(); // invalid
 
+  // ignore: avoid_setters_without_getters
   static set instance(ConstVerifyTokenPluginPlatform instance) {
     PlatformInterface.verifyToken(instance, _token);
   }
diff --git a/packages/quick_actions/quick_actions/CHANGELOG.md b/packages/quick_actions/quick_actions/CHANGELOG.md
index 73540a8..d7703a8 100644
--- a/packages/quick_actions/quick_actions/CHANGELOG.md
+++ b/packages/quick_actions/quick_actions/CHANGELOG.md
@@ -1,3 +1,7 @@
+## NEXT
+
+* Minor fixes for new analysis options.
+
 ## 0.6.0+11
 
 * Removes unnecessary imports.
diff --git a/packages/quick_actions/quick_actions/test/quick_actions_test.dart b/packages/quick_actions/quick_actions/test/quick_actions_test.dart
index 2747818..be9fd5e 100644
--- a/packages/quick_actions/quick_actions/test/quick_actions_test.dart
+++ b/packages/quick_actions/quick_actions/test/quick_actions_test.dart
@@ -21,7 +21,7 @@
 
     test('initialize() PlatformInterface', () async {
       const QuickActions quickActions = QuickActions();
-      final QuickActionHandler handler = (String type) {};
+      void handler(String type) {}
 
       await quickActions.initialize(handler);
       verify(QuickActionsPlatform.instance.initialize(handler)).called(1);
@@ -29,7 +29,7 @@
 
     test('setShortcutItems() PlatformInterface', () {
       const QuickActions quickActions = QuickActions();
-      final QuickActionHandler handler = (String type) {};
+      void handler(String type) {}
       quickActions.initialize(handler);
       quickActions.setShortcutItems(<ShortcutItem>[]);
 
@@ -40,7 +40,7 @@
 
     test('clearShortcutItems() PlatformInterface', () {
       const QuickActions quickActions = QuickActions();
-      final QuickActionHandler handler = (String type) {};
+      void handler(String type) {}
 
       quickActions.initialize(handler);
       quickActions.clearShortcutItems();
diff --git a/packages/shared_preferences/shared_preferences/CHANGELOG.md b/packages/shared_preferences/shared_preferences/CHANGELOG.md
index 22c39aa..4bf0f6a 100644
--- a/packages/shared_preferences/shared_preferences/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 2.0.15
+
+* Minor fixes for new analysis options.
+
 ## 2.0.14
 
 * Adds OS version support information to README.
diff --git a/packages/shared_preferences/shared_preferences/lib/shared_preferences.dart b/packages/shared_preferences/shared_preferences/lib/shared_preferences.dart
index 5e2a658..77f0480 100644
--- a/packages/shared_preferences/shared_preferences/lib/shared_preferences.dart
+++ b/packages/shared_preferences/shared_preferences/lib/shared_preferences.dart
@@ -140,7 +140,7 @@
 
   /// Always returns true.
   /// On iOS, synchronize is marked deprecated. On Android, we commit every set.
-  @deprecated
+  @Deprecated('This method is now a no-op, and should no longer be called.')
   Future<bool> commit() async => true;
 
   /// Completes with true once the user preferences for the app has been cleared.
diff --git a/packages/shared_preferences/shared_preferences/pubspec.yaml b/packages/shared_preferences/shared_preferences/pubspec.yaml
index 4218095..14b56fe 100644
--- a/packages/shared_preferences/shared_preferences/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences/pubspec.yaml
@@ -3,7 +3,7 @@
   Wraps NSUserDefaults on iOS and SharedPreferences on Android.
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.0.14
+version: 2.0.15
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences/test/shared_preferences_test.dart b/packages/shared_preferences/shared_preferences/test/shared_preferences_test.dart
index 11498cf..0a02c46 100755
--- a/packages/shared_preferences/shared_preferences/test/shared_preferences_test.dart
+++ b/packages/shared_preferences/shared_preferences/test/shared_preferences_test.dart
@@ -172,7 +172,7 @@
 
     group('mocking', () {
       const String _key = 'dummy';
-      const String _prefixedKey = 'flutter.' + _key;
+      const String _prefixedKey = 'flutter.$_key';
 
       test('test 1', () async {
         SharedPreferences.setMockInitialValues(
diff --git a/packages/url_launcher/url_launcher/CHANGELOG.md b/packages/url_launcher/url_launcher/CHANGELOG.md
index 493412c..043edeb 100644
--- a/packages/url_launcher/url_launcher/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 6.1.2
+
+* Minor fixes for new analysis options.
+
 ## 6.1.1
 
 * Removes unnecessary imports.
diff --git a/packages/url_launcher/url_launcher/lib/src/legacy_api.dart b/packages/url_launcher/url_launcher/lib/src/legacy_api.dart
index a61b200..f6faf3f 100644
--- a/packages/url_launcher/url_launcher/lib/src/legacy_api.dart
+++ b/packages/url_launcher/url_launcher/lib/src/legacy_api.dart
@@ -76,10 +76,10 @@
   final bool isWebURL =
       url != null && (url.scheme == 'http' || url.scheme == 'https');
 
-  if ((forceSafariVC == true || forceWebView == true) && !isWebURL) {
+  if ((forceSafariVC ?? false || forceWebView) && !isWebURL) {
     throw PlatformException(
         code: 'NOT_A_WEB_SCHEME',
-        message: 'To use webview or safariVC, you need to pass'
+        message: 'To use webview or safariVC, you need to pass '
             'in a web URL. This $urlString is not a web URL.');
   }
 
diff --git a/packages/url_launcher/url_launcher/pubspec.yaml b/packages/url_launcher/url_launcher/pubspec.yaml
index c14b62a..2cf75df 100644
--- a/packages/url_launcher/url_launcher/pubspec.yaml
+++ b/packages/url_launcher/url_launcher/pubspec.yaml
@@ -3,7 +3,7 @@
   web, phone, SMS, and email schemes.
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 6.1.1
+version: 6.1.2
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/url_launcher/url_launcher/test/mocks/mock_url_launcher_platform.dart b/packages/url_launcher/url_launcher/test/mocks/mock_url_launcher_platform.dart
index 789c143..5c53257 100644
--- a/packages/url_launcher/url_launcher/test/mocks/mock_url_launcher_platform.dart
+++ b/packages/url_launcher/url_launcher/test/mocks/mock_url_launcher_platform.dart
@@ -25,6 +25,7 @@
   bool canLaunchCalled = false;
   bool launchCalled = false;
 
+  // ignore: use_setters_to_change_properties
   void setCanLaunchExpectations(String url) {
     this.url = url;
   }
@@ -49,6 +50,7 @@
     this.webOnlyWindowName = webOnlyWindowName;
   }
 
+  // ignore: use_setters_to_change_properties
   void setResponse(bool response) {
     this.response = response;
   }
diff --git a/packages/url_launcher/url_launcher_web/CHANGELOG.md b/packages/url_launcher/url_launcher_web/CHANGELOG.md
index b53a92c..068650b 100644
--- a/packages/url_launcher/url_launcher_web/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher_web/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 2.0.11
+
+* Minor fixes for new analysis options.
+
 ## 2.0.10
 
 * Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
diff --git a/packages/url_launcher/url_launcher_web/lib/url_launcher_web.dart b/packages/url_launcher/url_launcher_web/lib/url_launcher_web.dart
index 72540c3..636cd8c 100644
--- a/packages/url_launcher/url_launcher_web/lib/url_launcher_web.dart
+++ b/packages/url_launcher/url_launcher_web/lib/url_launcher_web.dart
@@ -64,6 +64,7 @@
     // See https://github.com/flutter/flutter/issues/51461 for reference.
     final String target = webOnlyWindowName ??
         ((_isSafari && _isSafariTargetTopScheme(url)) ? '_top' : '');
+    // ignore: unsafe_html
     return _window.open(url, target);
   }
 
diff --git a/packages/url_launcher/url_launcher_web/pubspec.yaml b/packages/url_launcher/url_launcher_web/pubspec.yaml
index cd8ed2d..cef3230 100644
--- a/packages/url_launcher/url_launcher_web/pubspec.yaml
+++ b/packages/url_launcher/url_launcher_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of url_launcher
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 2.0.10
+version: 2.0.11
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/video_player/video_player/CHANGELOG.md b/packages/video_player/video_player/CHANGELOG.md
index ede8901..1dbc4f7 100644
--- a/packages/video_player/video_player/CHANGELOG.md
+++ b/packages/video_player/video_player/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 2.4.2
+
+* Minor fixes for new analysis options.
+
 ## 2.4.1
 
 * Removes unnecessary imports.
diff --git a/packages/video_player/video_player/example/integration_test/video_player_test.dart b/packages/video_player/video_player/example/integration_test/video_player_test.dart
index 151eb93..633d636 100644
--- a/packages/video_player/video_player/example/integration_test/video_player_test.dart
+++ b/packages/video_player/video_player/example/integration_test/video_player_test.dart
@@ -182,7 +182,7 @@
             child: FutureBuilder<bool>(
               future: started(),
               builder: (BuildContext context, AsyncSnapshot<bool> snapshot) {
-                if (snapshot.data == true) {
+                if (snapshot.data ?? false) {
                   return AspectRatio(
                     aspectRatio: _controller.value.aspectRatio,
                     child: VideoPlayer(_controller),
diff --git a/packages/video_player/video_player/example/lib/main.dart b/packages/video_player/video_player/example/lib/main.dart
index f587597..63afc4a 100644
--- a/packages/video_player/video_player/example/lib/main.dart
+++ b/packages/video_player/video_player/example/lib/main.dart
@@ -424,7 +424,7 @@
         child: FutureBuilder<bool>(
           future: started(),
           builder: (BuildContext context, AsyncSnapshot<bool> snapshot) {
-            if (snapshot.data == true) {
+            if (snapshot.data ?? false) {
               return AspectRatio(
                 aspectRatio: _videoPlayerController.value.aspectRatio,
                 child: VideoPlayer(_videoPlayerController),
diff --git a/packages/video_player/video_player/pubspec.yaml b/packages/video_player/video_player/pubspec.yaml
index b0ca564..05cfcf1 100644
--- a/packages/video_player/video_player/pubspec.yaml
+++ b/packages/video_player/video_player/pubspec.yaml
@@ -3,7 +3,7 @@
   widgets on Android, iOS, and web.
 repository: https://github.com/flutter/plugins/tree/main/packages/video_player/video_player
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+video_player%22
-version: 2.4.1
+version: 2.4.2
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/video_player/video_player/test/closed_caption_file_test.dart b/packages/video_player/video_player/test/closed_caption_file_test.dart
index b5c0a8e..a20f947 100644
--- a/packages/video_player/video_player/test/closed_caption_file_test.dart
+++ b/packages/video_player/video_player/test/closed_caption_file_test.dart
@@ -21,8 +21,7 @@
           'number: 1, '
           'start: 0:00:01.000000, '
           'end: 0:00:02.000000, '
-          'text: caption'
-          ')');
+          'text: caption)');
     });
   });
 }
diff --git a/packages/video_player/video_player/test/sub_rip_file_test.dart b/packages/video_player/video_player/test/sub_rip_file_test.dart
index ea3bfda..82fe6ce 100644
--- a/packages/video_player/video_player/test/sub_rip_file_test.dart
+++ b/packages/video_player/video_player/test/sub_rip_file_test.dart
@@ -57,7 +57,7 @@
     );
     expect(
       fourthCaption.text,
-      '- [ Machinery Beeping ]\n- I\'m not sure what that was,',
+      "- [ Machinery Beeping ]\n- I'm not sure what that was,",
     );
   });
 
diff --git a/packages/video_player/video_player_web/CHANGELOG.md b/packages/video_player/video_player_web/CHANGELOG.md
index 094ffda..e36d044 100644
--- a/packages/video_player/video_player_web/CHANGELOG.md
+++ b/packages/video_player/video_player_web/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 2.0.10
+
+* Minor fixes for new analysis options.
+
 ## 2.0.9
 
 * Removes unnecessary imports.
diff --git a/packages/video_player/video_player_web/lib/src/video_player.dart b/packages/video_player/video_player_web/lib/src/video_player.dart
index 45d90d6..0761673 100644
--- a/packages/video_player/video_player_web/lib/src/video_player.dart
+++ b/packages/video_player/video_player_web/lib/src/video_player.dart
@@ -134,6 +134,7 @@
   }
 
   /// Controls whether the video should start again after it finishes.
+  // ignore: use_setters_to_change_properties
   void setLooping(bool value) {
     _videoElement.loop = value;
   }
diff --git a/packages/video_player/video_player_web/pubspec.yaml b/packages/video_player/video_player_web/pubspec.yaml
index 7af0dc4..04fba27 100644
--- a/packages/video_player/video_player_web/pubspec.yaml
+++ b/packages/video_player/video_player_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of video_player.
 repository: https://github.com/flutter/plugins/tree/main/packages/video_player/video_player_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+video_player%22
-version: 2.0.9
+version: 2.0.10
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter/CHANGELOG.md b/packages/webview_flutter/webview_flutter/CHANGELOG.md
index fa47a6c..31c16da 100644
--- a/packages/webview_flutter/webview_flutter/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 3.0.4
+
+* Minor fixes for new analysis options.
+
 ## 3.0.3
 
 * Removes unnecessary imports.
diff --git a/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart b/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart
index cc001f3..066ac03 100644
--- a/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart
+++ b/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart
@@ -912,8 +912,8 @@
 
   group('NavigationDelegate', () {
     const String blankPage = '<!DOCTYPE html><head></head><body></body></html>';
-    final String blankPageEncoded = 'data:text/html;charset=utf-8;base64,' +
-        base64Encode(const Utf8Encoder().convert(blankPage));
+    final String blankPageEncoded = 'data:text/html;charset=utf-8;base64,'
+        '${base64Encode(const Utf8Encoder().convert(blankPage))}';
 
     testWidgets('can allow requests', (WidgetTester tester) async {
       final Completer<WebViewController> controllerCompleter =
diff --git a/packages/webview_flutter/webview_flutter/example/lib/main.dart b/packages/webview_flutter/webview_flutter/example/lib/main.dart
index 3d87311..79197b0 100644
--- a/packages/webview_flutter/webview_flutter/example/lib/main.dart
+++ b/packages/webview_flutter/webview_flutter/example/lib/main.dart
@@ -40,8 +40,8 @@
 
 <h1>Local demo page</h1>
 <p>
-  This is an example page used to demonstrate how to load a local file or HTML 
-  string using the <a href="https://pub.dev/packages/webview_flutter">Flutter 
+  This is an example page used to demonstrate how to load a local file or HTML
+  string using the <a href="https://pub.dev/packages/webview_flutter">Flutter
   webview</a> plugin.
 </p>
 
@@ -155,7 +155,7 @@
             onPressed: () async {
               String? url;
               if (controller.hasData) {
-                url = (await controller.data!.currentUrl())!;
+                url = await controller.data!.currentUrl();
               }
               ScaffoldMessenger.of(context).showSnackBar(
                 SnackBar(
@@ -345,6 +345,7 @@
   Future<void> _onListCache(
       WebViewController controller, BuildContext context) async {
     await controller.runJavascript('caches.keys()'
+        // ignore: missing_whitespace_between_adjacent_strings
         '.then((cacheKeys) => JSON.stringify({"cacheKeys" : cacheKeys, "localStorage" : localStorage}))'
         '.then((caches) => Toaster.postMessage(caches))');
   }
diff --git a/packages/webview_flutter/webview_flutter/pubspec.yaml b/packages/webview_flutter/webview_flutter/pubspec.yaml
index a48f6f9..9639b6a 100644
--- a/packages/webview_flutter/webview_flutter/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget on Android and iOS.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 3.0.3
+version: 3.0.4
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter/test/webview_flutter_test.dart b/packages/webview_flutter/webview_flutter/test/webview_flutter_test.dart
index ad25cad..d718991 100644
--- a/packages/webview_flutter/webview_flutter/test/webview_flutter_test.dart
+++ b/packages/webview_flutter/webview_flutter/test/webview_flutter_test.dart
@@ -588,7 +588,7 @@
   });
 
   test('Only valid JavaScript channel names are allowed', () {
-    final JavascriptMessageHandler noOp = (JavascriptMessage msg) {};
+    void noOp(JavascriptMessage msg) {}
     JavascriptChannel(name: 'Tts1', onMessageReceived: noOp);
     JavascriptChannel(name: '_Alarm', onMessageReceived: noOp);
     JavascriptChannel(name: 'foo_bar_', onMessageReceived: noOp);
diff --git a/packages/webview_flutter/webview_flutter_android/CHANGELOG.md b/packages/webview_flutter/webview_flutter_android/CHANGELOG.md
index 4a45144..41a6fa2 100644
--- a/packages/webview_flutter/webview_flutter_android/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter_android/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 2.8.8
+
+* Minor fixes for new analysis options.
+
 ## 2.8.7
 
 * Removes unnecessary imports.
diff --git a/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart b/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart
index 4c06fa6..383fe45 100644
--- a/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart
+++ b/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart
@@ -1009,8 +1009,8 @@
 
   group('NavigationDelegate', () {
     const String blankPage = '<!DOCTYPE html><head></head><body></body></html>';
-    final String blankPageEncoded = 'data:text/html;charset=utf-8;base64,' +
-        base64Encode(const Utf8Encoder().convert(blankPage));
+    final String blankPageEncoded = 'data:text/html;charset=utf-8;base64,'
+        '${base64Encode(const Utf8Encoder().convert(blankPage))}';
 
     testWidgets('can allow requests', (WidgetTester tester) async {
       final Completer<WebViewController> controllerCompleter =
diff --git a/packages/webview_flutter/webview_flutter_android/example/lib/main.dart b/packages/webview_flutter/webview_flutter_android/example/lib/main.dart
index 349a649..4492e6e 100644
--- a/packages/webview_flutter/webview_flutter_android/example/lib/main.dart
+++ b/packages/webview_flutter/webview_flutter_android/example/lib/main.dart
@@ -56,8 +56,8 @@
 
 <h1>Local demo page</h1>
 <p>
-  This is an example page used to demonstrate how to load a local file or HTML 
-  string using the <a href="https://pub.dev/packages/webview_flutter">Flutter 
+  This is an example page used to demonstrate how to load a local file or HTML
+  string using the <a href="https://pub.dev/packages/webview_flutter">Flutter
   webview</a> plugin.
 </p>
 
@@ -341,6 +341,7 @@
   Future<void> _onListCache(
       WebViewController controller, BuildContext context) async {
     await controller.runJavascript('caches.keys()'
+        // ignore: missing_whitespace_between_adjacent_strings
         '.then((cacheKeys) => JSON.stringify({"cacheKeys" : cacheKeys, "localStorage" : localStorage}))'
         '.then((caches) => Snackbar.postMessage(caches))');
   }
diff --git a/packages/webview_flutter/webview_flutter_android/pubspec.yaml b/packages/webview_flutter/webview_flutter_android/pubspec.yaml
index 407887f..d6cf2b2 100644
--- a/packages/webview_flutter/webview_flutter_android/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget on Android.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 2.8.7
+version: 2.8.8
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter_web/CHANGELOG.md b/packages/webview_flutter/webview_flutter_web/CHANGELOG.md
index b7254e1..8ab70f9 100644
--- a/packages/webview_flutter/webview_flutter_web/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter_web/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.1.0+3
+
+* Minor fixes for new analysis options.
+
 ## 0.1.0+2
 
 * Removes unnecessary imports.
diff --git a/packages/webview_flutter/webview_flutter_web/lib/webview_flutter_web.dart b/packages/webview_flutter/webview_flutter_web/lib/webview_flutter_web.dart
index aa427eb..637c249 100644
--- a/packages/webview_flutter/webview_flutter_web/lib/webview_flutter_web.dart
+++ b/packages/webview_flutter/webview_flutter_web/lib/webview_flutter_web.dart
@@ -44,6 +44,7 @@
         final IFrameElement element =
             document.getElementById('webview-$viewId')! as IFrameElement;
         if (creationParams.initialUrl != null) {
+          // ignore: unsafe_html
           element.src = creationParams.initialUrl;
         }
         onWebViewPlatformCreated(WebWebViewPlatformController(
@@ -70,6 +71,7 @@
 
   /// Setter for setting the HttpRequestFactory, for testing purposes.
   @visibleForTesting
+  // ignore: avoid_setters_without_getters
   set httpRequestFactory(HttpRequestFactory factory) {
     _httpRequestFactory = factory;
   }
@@ -131,6 +133,7 @@
 
   @override
   Future<void> loadUrl(String url, Map<String, String>? headers) async {
+    // ignore: unsafe_html
     _element.src = url;
   }
 
@@ -179,7 +182,8 @@
     String html, {
     String? baseUrl,
   }) async {
-    _element.src = 'data:text/html,' + Uri.encodeFull(html);
+    // ignore: unsafe_html
+    _element.src = 'data:text/html,${Uri.encodeFull(html)}';
   }
 
   @override
@@ -194,8 +198,9 @@
         sendData: request.body);
     final String contentType =
         httpReq.getResponseHeader('content-type') ?? 'text/html';
+    // ignore: unsafe_html
     _element.src =
-        'data:$contentType,' + Uri.encodeFull(httpReq.responseText ?? '');
+        'data:$contentType,${Uri.encodeFull(httpReq.responseText ?? '')}';
   }
 
   @override
@@ -265,7 +270,7 @@
       String? mimeType,
       Map<String, String>? requestHeaders,
       dynamic sendData,
-      void onProgress(ProgressEvent e)?}) {
+      void Function(ProgressEvent e)? onProgress}) {
     return HttpRequest.request(url,
         method: method,
         withCredentials: withCredentials,
diff --git a/packages/webview_flutter/webview_flutter_web/pubspec.yaml b/packages/webview_flutter/webview_flutter_web/pubspec.yaml
index 35a7b74..a834c9b 100644
--- a/packages/webview_flutter/webview_flutter_web/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget on web.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 0.1.0+2
+version: 0.1.0+3
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter_web/test/webview_flutter_web_test.dart b/packages/webview_flutter/webview_flutter_web/test/webview_flutter_web_test.dart
index 90e2ea4..6058dcf 100644
--- a/packages/webview_flutter/webview_flutter_web/test/webview_flutter_web_test.dart
+++ b/packages/webview_flutter/webview_flutter_web/test/webview_flutter_web_test.dart
@@ -64,7 +64,7 @@
       // Run
       controller.loadHtmlString('test html');
       // Verify
-      verify(mockElement.src = 'data:text/html,' + Uri.encodeFull('test html'));
+      verify(mockElement.src = 'data:text/html,${Uri.encodeFull('test html')}');
     });
 
     group('loadRequest', () {
@@ -123,7 +123,7 @@
           sendData: Uint8List.fromList('test body'.codeUnits),
         ));
         verify(
-            mockElement.src = 'data:text/plain,' + Uri.encodeFull('test data'));
+            mockElement.src = 'data:text/plain,${Uri.encodeFull('test data')}');
       });
     });
   });
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md b/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md
index 6db769b..00aa729 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 2.7.5
+
+* Minor fixes for new analysis options.
+
 ## 2.7.4
 
 * Removes unnecessary imports.
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart b/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart
index aa376f8..40018ee 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart
@@ -861,8 +861,8 @@
 
   group('NavigationDelegate', () {
     const String blankPage = '<!DOCTYPE html><head></head><body></body></html>';
-    final String blankPageEncoded = 'data:text/html;charset=utf-8;base64,' +
-        base64Encode(const Utf8Encoder().convert(blankPage));
+    final String blankPageEncoded = 'data:text/html;charset=utf-8;base64,'
+        '${base64Encode(const Utf8Encoder().convert(blankPage))}';
 
     testWidgets('can allow requests', (WidgetTester tester) async {
       final Completer<WebViewController> controllerCompleter =
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart b/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart
index 7b30923..3f61ebf 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart
@@ -326,6 +326,7 @@
   Future<void> _onListCache(
       WebViewController controller, BuildContext context) async {
     await controller.runJavascript('caches.keys()'
+        // ignore: missing_whitespace_between_adjacent_strings
         '.then((cacheKeys) => JSON.stringify({"cacheKeys" : cacheKeys, "localStorage" : localStorage}))'
         '.then((caches) => Snackbar.postMessage(caches))');
   }
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart b/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart
index 0a177d8..19051af 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart
@@ -167,7 +167,7 @@
     webView.setNavigationDelegate(navigationDelegate);
 
     if (params.userAgent != null) {
-      webView.setCustomUserAgent(params.userAgent!);
+      webView.setCustomUserAgent(params.userAgent);
     }
 
     if (params.webSettings != null) {
@@ -177,7 +177,7 @@
     if (params.backgroundColor != null) {
       webView.setOpaque(false);
       webView.setBackgroundColor(Colors.transparent);
-      webView.scrollView.setBackgroundColor(params.backgroundColor!);
+      webView.scrollView.setBackgroundColor(params.backgroundColor);
     }
 
     if (params.initialUrl != null) {
@@ -496,10 +496,10 @@
 
   Future<void> _disableZoom() {
     const WKUserScript userScript = WKUserScript(
-      "var meta = document.createElement('meta');"
-      "meta.name = 'viewport';"
-      "meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0,"
-      "user-scalable=no';"
+      "var meta = document.createElement('meta');\n"
+      "meta.name = 'viewport';\n"
+      "meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0, "
+      "user-scalable=no';\n"
       "var head = document.getElementsByTagName('head')[0];head.appendChild(meta);",
       WKUserScriptInjectionTime.atDocumentEnd,
       isMainFrameOnly: true,
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml b/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml
index 365e647..d85bf32 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget based on Apple's WKWebView control.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter_wkwebview
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 2.7.4
+version: 2.7.5
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/test/src/common/function_flutter_api_test.dart b/packages/webview_flutter/webview_flutter_wkwebview/test/src/common/function_flutter_api_test.dart
index 63e5938..6af9510 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/test/src/common/function_flutter_api_test.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/test/src/common/function_flutter_api_test.dart
@@ -18,7 +18,7 @@
     });
 
     test('dispose', () {
-      final Function function = () {};
+      void function() {}
       final int functionInstanceId = instanceManager.tryAddInstance(function)!;
 
       FoundationFlutterApis.instance = FoundationFlutterApis(
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit/web_kit_test.dart b/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit/web_kit_test.dart
index ae13ca9..b09f346 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit/web_kit_test.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit/web_kit_test.dart
@@ -163,7 +163,7 @@
 
         final NSHttpCookieData cookie = verify(
           mockPlatformHostApi.setCookie(
-            instanceManager.getInstanceId(httpCookieStore)!,
+            instanceManager.getInstanceId(httpCookieStore),
             captureAny,
           ),
         ).captured.single as NSHttpCookieData;
@@ -373,8 +373,8 @@
           instanceManager: instanceManager,
         );
         verify(mockPlatformHostApi.createFromWebView(
-          instanceManager.getInstanceId(configurationFromWebView)!,
-          instanceManager.getInstanceId(webView)!,
+          instanceManager.getInstanceId(configurationFromWebView),
+          instanceManager.getInstanceId(webView),
         ));
       });
 
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit_webview_widget_test.dart b/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit_webview_widget_test.dart
index d77feee..271fd5c 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit_webview_widget_test.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/test/src/web_kit_webview_widget_test.dart
@@ -400,10 +400,10 @@
               WKUserScriptInjectionTime.atDocumentEnd);
           expect(
             zoomScript.source,
-            "var meta = document.createElement('meta');"
-            "meta.name = 'viewport';"
-            "meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0,"
-            "user-scalable=no';"
+            "var meta = document.createElement('meta');\n"
+            "meta.name = 'viewport';\n"
+            "meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0, "
+            "user-scalable=no';\n"
             "var head = document.getElementsByTagName('head')[0];head.appendChild(meta);",
           );
         });
@@ -892,10 +892,10 @@
             zoomScript.injectionTime, WKUserScriptInjectionTime.atDocumentEnd);
         expect(
           zoomScript.source,
-          "var meta = document.createElement('meta');"
-          "meta.name = 'viewport';"
-          "meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0,"
-          "user-scalable=no';"
+          "var meta = document.createElement('meta');\n"
+          "meta.name = 'viewport';\n"
+          "meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0, "
+          "user-scalable=no';\n"
           "var head = document.getElementsByTagName('head')[0];head.appendChild(meta);",
         );
       });
diff --git a/script/tool/lib/src/create_all_plugins_app_command.dart b/script/tool/lib/src/create_all_plugins_app_command.dart
index ad836e1..595779b 100644
--- a/script/tool/lib/src/create_all_plugins_app_command.dart
+++ b/script/tool/lib/src/create_all_plugins_app_command.dart
@@ -110,7 +110,7 @@
         newGradle.writeln('        multiDexEnabled true');
       } else if (line.contains('dependencies {')) {
         newGradle.writeln(
-          '    implementation \'com.google.guava:guava:27.0.1-android\'\n',
+          "    implementation 'com.google.guava:guava:27.0.1-android'\n",
         );
         // Tests for https://github.com/flutter/flutter/issues/43383
         newGradle.writeln(
diff --git a/script/tool/lib/src/custom_test_command.dart b/script/tool/lib/src/custom_test_command.dart
index cd9ac32..0ef6e60 100644
--- a/script/tool/lib/src/custom_test_command.dart
+++ b/script/tool/lib/src/custom_test_command.dart
@@ -30,7 +30,7 @@
 
   @override
   final String description = 'Runs package-specific custom tests defined in '
-      'a package\'s tool/$_scriptName file.\n\n'
+      "a package's tool/$_scriptName file.\n\n"
       'This command requires "dart" to be in your path.';
 
   @override
diff --git a/script/tool/lib/src/format_command.dart b/script/tool/lib/src/format_command.dart
index 10c0779..f640cba 100644
--- a/script/tool/lib/src/format_command.dart
+++ b/script/tool/lib/src/format_command.dart
@@ -130,8 +130,7 @@
     if (clangFiles.isNotEmpty) {
       final String clangFormat = getStringArg('clang-format');
       if (!await _hasDependency(clangFormat)) {
-        printError(
-            'Unable to run \'clang-format\'. Make sure that it is in your '
+        printError('Unable to run "clang-format". Make sure that it is in your '
             'path, or provide a full path with --clang-format.');
         throw ToolExit(_exitDependencyMissing);
       }
@@ -156,7 +155,7 @@
       final String java = getStringArg('java');
       if (!await _hasDependency(java)) {
         printError(
-            'Unable to run \'java\'. Make sure that it is in your path, or '
+            'Unable to run "java". Make sure that it is in your path, or '
             'provide a full path with --java.');
         throw ToolExit(_exitDependencyMissing);
       }
diff --git a/script/tool/lib/src/license_check_command.dart b/script/tool/lib/src/license_check_command.dart
index 87e4c8b..5e74d84 100644
--- a/script/tool/lib/src/license_check_command.dart
+++ b/script/tool/lib/src/license_check_command.dart
@@ -241,8 +241,7 @@
     }
 
     // Sort by path for more usable output.
-    final int Function(File, File) pathCompare =
-        (File a, File b) => a.path.compareTo(b.path);
+    int pathCompare(File a, File b) => a.path.compareTo(b.path);
     incorrectFirstPartyFiles.sort(pathCompare);
     unrecognizedThirdPartyFiles.sort(pathCompare);
 
diff --git a/script/tool/lib/src/make_deps_path_based_command.dart b/script/tool/lib/src/make_deps_path_based_command.dart
index 9b861c3..4bbecb4 100644
--- a/script/tool/lib/src/make_deps_path_based_command.dart
+++ b/script/tool/lib/src/make_deps_path_based_command.dart
@@ -169,8 +169,8 @@
       // then re-serialiazing so that it's a localized change, rather than
       // rewriting the whole file (e.g., destroying comments), which could be
       // more disruptive for local use.
-      String newPubspecContents = pubspecContents +
-          '''
+      String newPubspecContents = '''
+$pubspecContents
 
 $_dependencyOverrideWarningComment
 dependency_overrides:
diff --git a/script/tool/lib/src/pubspec_check_command.dart b/script/tool/lib/src/pubspec_check_command.dart
index 654675e..23c9c00 100644
--- a/script/tool/lib/src/pubspec_check_command.dart
+++ b/script/tool/lib/src/pubspec_check_command.dart
@@ -225,8 +225,8 @@
   bool _checkIssueLink(Pubspec pubspec) {
     return pubspec.issueTracker
             ?.toString()
-            .startsWith(_expectedIssueLinkFormat) ==
-        true;
+            .startsWith(_expectedIssueLinkFormat) ??
+        false;
   }
 
   // Validates the "implements" keyword for a plugin, returning an error
@@ -287,8 +287,8 @@
         .where((String package) => !dependencies.contains(package));
     if (missingPackages.isNotEmpty) {
       return 'The following default_packages are missing '
-              'corresponding dependencies:\n  ' +
-          missingPackages.join('\n  ');
+          'corresponding dependencies:\n'
+          '  ${missingPackages.join('\n  ')}';
     }
 
     return null;
diff --git a/script/tool/lib/src/version_check_command.dart b/script/tool/lib/src/version_check_command.dart
index c0e6776..b816ee5 100644
--- a/script/tool/lib/src/version_check_command.dart
+++ b/script/tool/lib/src/version_check_command.dart
@@ -403,7 +403,7 @@
 
     final String badNextErrorMessage = '${indentation}When bumping the version '
         'for release, the NEXT section should be incorporated into the new '
-        'version\'s release notes.';
+        "version's release notes.";
 
     // Skip validation for the special NEXT version that's used to accumulate
     // changes that don't warrant publishing on their own.
@@ -531,7 +531,7 @@
     final Directory gitRoot =
         packagesDir.fileSystem.directory((await gitDir).path);
     final String relativePackagePath =
-        getRelativePosixPath(package.directory, from: gitRoot) + '/';
+        '${getRelativePosixPath(package.directory, from: gitRoot)}/';
     bool hasChanges = false;
     bool needsVersionChange = false;
     bool hasChangelogChange = false;
@@ -594,7 +594,7 @@
             'change description.');
       } else {
         printError(
-            'No CHANGELOG change found. If this PR needs an exemption from'
+            'No CHANGELOG change found. If this PR needs an exemption from '
             'the standard policy of listing all changes in the CHANGELOG, '
             'please add a line starting with\n'
             '$_missingChangelogChangeJustificationMarker\n'
diff --git a/script/tool/test/analyze_command_test.dart b/script/tool/test/analyze_command_test.dart
index e293e8b..a9b8334 100644
--- a/script/tool/test/analyze_command_test.dart
+++ b/script/tool/test/analyze_command_test.dart
@@ -93,7 +93,7 @@
         ]));
   });
 
-  test('don\'t elide a non-contained example package', () async {
+  test("don't elide a non-contained example package", () async {
     final RepositoryPackage plugin1 = createFakePlugin('a', packagesDir);
     final RepositoryPackage plugin2 = createFakePlugin('example', packagesDir);
 
diff --git a/script/tool/test/common/plugin_command_test.dart b/script/tool/test/common/plugin_command_test.dart
index 7ed3d23..8c6b386 100644
--- a/script/tool/test/common/plugin_command_test.dart
+++ b/script/tool/test/common/plugin_command_test.dart
@@ -162,7 +162,7 @@
       expect(command.plugins, unorderedEquals(<String>[plugin2.path]));
     });
 
-    test('exclude packages when packages flag isn\'t specified', () async {
+    test("exclude packages when packages flag isn't specified", () async {
       createFakePlugin('plugin1', packagesDir);
       createFakePlugin('plugin2', packagesDir);
       await runCapturingPrint(
diff --git a/script/tool/test/format_command_test.dart b/script/tool/test/format_command_test.dart
index 3fa7782..5bd6f97 100644
--- a/script/tool/test/format_command_test.dart
+++ b/script/tool/test/format_command_test.dart
@@ -218,7 +218,7 @@
         output,
         containsAllInOrder(<Matcher>[
           contains(
-              'Unable to run \'java\'. Make sure that it is in your path, or '
+              'Unable to run "java". Make sure that it is in your path, or '
               'provide a full path with --java.'),
         ]));
   });
@@ -330,8 +330,7 @@
     expect(
         output,
         containsAllInOrder(<Matcher>[
-          contains(
-              'Unable to run \'clang-format\'. Make sure that it is in your '
+          contains('Unable to run "clang-format". Make sure that it is in your '
               'path, or provide a full path with --clang-format.'),
         ]));
   });
diff --git a/script/tool/test/publish_plugin_command_test.dart b/script/tool/test/publish_plugin_command_test.dart
index 857828a..d443f8f 100644
--- a/script/tool/test/publish_plugin_command_test.dart
+++ b/script/tool/test/publish_plugin_command_test.dart
@@ -103,7 +103,7 @@
       expect(
           output,
           containsAllInOrder(<Matcher>[
-            contains('There are files in the package directory that haven\'t '
+            contains("There are files in the package directory that haven't "
                 'been saved in git. Refusing to publish these files:\n\n'
                 '?? /packages/foo/tmp\n\n'
                 'If the directory should be clean, you can run `git clean -xdf && '
@@ -113,7 +113,7 @@
           ]));
     });
 
-    test('fails immediately if the remote doesn\'t exist', () async {
+    test("fails immediately if the remote doesn't exist", () async {
       createFakePlugin('foo', packagesDir, examples: <String>[]);
 
       processRunner.mockProcessesForExecutable['git-remote'] = <io.Process>[
@@ -877,8 +877,8 @@
   }
 
   @override
-  StreamSubscription<List<int>> listen(void onData(List<int> event)?,
-      {Function? onError, void onDone()?, bool? cancelOnError}) {
+  StreamSubscription<List<int>> listen(void Function(List<int> event)? onData,
+      {Function? onError, void Function()? onDone, bool? cancelOnError}) {
     return _controller.stream.listen(onData,
         onError: onError, onDone: onDone, cancelOnError: cancelOnError);
   }
diff --git a/script/tool/test/pubspec_check_command_test.dart b/script/tool/test/pubspec_check_command_test.dart
index 89bb98a..fbe31c7 100644
--- a/script/tool/test/pubspec_check_command_test.dart
+++ b/script/tool/test/pubspec_check_command_test.dart
@@ -43,7 +43,7 @@
     repositoryPath,
   ];
   final String repoLink =
-      'https://github.com/' + repoLinkPathComponents.join('/');
+      'https://github.com/${repoLinkPathComponents.join('/')}';
   final String issueTrackerLink = 'https://github.com/flutter/flutter/issues?'
       'q=is%3Aissue+is%3Aopen+label%3A%22p%3A+$name%22';
   description ??= 'A test package for validating that the pubspec.yaml '
@@ -55,7 +55,7 @@
 ${includeHomepage ? 'homepage: $repoLink' : ''}
 ${includeIssueTracker ? 'issue_tracker: $issueTrackerLink' : ''}
 version: 1.0.0
-${publishable ? '' : 'publish_to: \'none\''}
+${publishable ? '' : "publish_to: 'none'"}
 ''';
 }
 
diff --git a/script/tool/test/util.dart b/script/tool/test/util.dart
index b0a8990..effdd03 100644
--- a/script/tool/test/util.dart
+++ b/script/tool/test/util.dart
@@ -313,7 +313,7 @@
         assert(false, 'Unrecognized platform: $platform');
         break;
     }
-    entry = lines.join('\n') + '\n';
+    entry = '${lines.join('\n')}\n';
   }
 
   return entry;
diff --git a/script/tool/test/version_check_command_test.dart b/script/tool/test/version_check_command_test.dart
index 5b8ed97..6af3c11 100644
--- a/script/tool/test/version_check_command_test.dart
+++ b/script/tool/test/version_check_command_test.dart
@@ -561,7 +561,7 @@
         output,
         containsAllInOrder(<Matcher>[
           contains('When bumping the version for release, the NEXT section '
-              'should be incorporated into the new version\'s release notes.')
+              "should be incorporated into the new version's release notes.")
         ]),
       );
     });
@@ -595,7 +595,7 @@
         output,
         containsAllInOrder(<Matcher>[
           contains('When bumping the version for release, the NEXT section '
-              'should be incorporated into the new version\'s release notes.'),
+              "should be incorporated into the new version's release notes."),
           contains('plugin:\n'
               '    CHANGELOG.md failed validation.'),
         ]),
@@ -627,7 +627,7 @@
         output,
         containsAllInOrder(<Matcher>[
           contains('When bumping the version for release, the NEXT section '
-              'should be incorporated into the new version\'s release notes.')
+              "should be incorporated into the new version's release notes.")
         ]),
       );
     });
