analyzer: Mark implicit-casts and implicit-dynamic as deprecated

Also add a fix which replaces 'implicit-casts' with 'strict-casts' and
a fix which replaces 'implicit-dynamic' with 'strict-raw-types'.

Fixes #47902

Change-Id: I293c3c1fd671ac85c12f9c050465b4d77632f241
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/224800
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: srawlins

pkg/analysis_server/lib/src/services/correction/fix.dart

@@ -40,6 +40,16 @@ class AnalysisOptionsFixKind {
     50,
     "Remove '{0}'",
   );
+  static const REPLACE_WITH_STRICT_CASTS = FixKind(
+    'analysisOptions.fix.replaceWithStrictCasts',
+    50,
+    'Replace with the strict-casts analysis mode',
+  );
+  static const REPLACE_WITH_STRICT_RAW_TYPES = FixKind(
+    'analysisOptions.fix.replaceWithStrictRawTypes',
+    50,
+    'Replace with the strict-raw-types analysis mode',
+  );
 }
 
 /// The implementation of [DartFixContext].

pkg/analysis_server/lib/src/services/correction/fix/analysis_options/fix_generator.dart

@@ -16,9 +16,12 @@ import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/lint/options_rule_validator.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_yaml.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_workspace.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
+import 'package:collection/collection.dart';
 import 'package:yaml/yaml.dart';
+import 'package:yaml_edit/yaml_edit.dart';
 
 /// The generator used to generate fixes in analysis options files.
 class AnalysisOptionsFixGenerator {
@@ -67,7 +70,26 @@ class AnalysisOptionsFixGenerator {
 //        AnalysisOptionsHintCode.STRONG_MODE_SETTING_DEPRECATED) {
 //    } else
 
-    if (errorCode == DEPRECATED_LINT_HINT) {
+    if (errorCode ==
+        AnalysisOptionsWarningCode
+            .ANALYSIS_OPTION_DEPRECATED_WITH_REPLACEMENT) {
+      var analyzerMap = options['analyzer'];
+      if (analyzerMap is! YamlMap) {
+        return fixes;
+      }
+      var strongModeMap = analyzerMap['strong-mode'];
+
+      if (strongModeMap is! YamlMap) {
+        return fixes;
+      }
+      if (_isErrorAtMapKey(strongModeMap, 'implicit-casts')) {
+        await _addFix_replaceWithStrictCasts(
+            coveringNodePath, analyzerMap, strongModeMap);
+      } else if (_isErrorAtMapKey(strongModeMap, 'implicit-dynamic')) {
+        await _addFix_replaceWithStrictRawTypes(
+            coveringNodePath, analyzerMap, strongModeMap);
+      }
+    } else if (errorCode == DEPRECATED_LINT_HINT) {
       await _addFix_removeLint(coveringNodePath);
     } else if (errorCode ==
         AnalysisOptionsHintCode.SUPER_MIXINS_SETTING_DEPRECATED) {
@@ -109,6 +131,52 @@ class AnalysisOptionsFixGenerator {
     }
   }
 
+  /// Replaces `analyzer: strong-mode: implicit-casts: false` with
+  /// `analyzer: language: strict-casts: true`.
+  Future<void> _addFix_replaceWithStrictCasts(List<YamlNode> coveringNodePath,
+      YamlMap analyzerMap, YamlMap strongModeMap) async {
+    var builder =
+        ChangeBuilder(workspace: _NonDartChangeWorkspace(resourceProvider));
+    await builder.addYamlFileEdit(file, (builder) {
+      _replaceStrongModeEntryWithLanguageEntry(
+        builder,
+        coveringNodePath,
+        analyzerMap,
+        strongModeMap,
+        strongModeKey: 'implicit-casts',
+        languageKey: 'strict-casts',
+        languageValue: true,
+      );
+    });
+    _addFixFromBuilder(
+        builder, AnalysisOptionsFixKind.REPLACE_WITH_STRICT_CASTS,
+        args: [coveringNodePath[0].toString()]);
+  }
+
+  /// Replaces `analyzer: strong-mode: implicit-dynamic: false` with
+  /// `analyzer: language: strict-raw-types: true`.
+  Future<void> _addFix_replaceWithStrictRawTypes(
+      List<YamlNode> coveringNodePath,
+      YamlMap analyzerMap,
+      YamlMap strongModeMap) async {
+    var builder =
+        ChangeBuilder(workspace: _NonDartChangeWorkspace(resourceProvider));
+    await builder.addYamlFileEdit(file, (builder) {
+      _replaceStrongModeEntryWithLanguageEntry(
+        builder,
+        coveringNodePath,
+        analyzerMap,
+        strongModeMap,
+        strongModeKey: 'implicit-dynamic',
+        languageKey: 'strict-raw-types',
+        languageValue: true,
+      );
+    });
+    _addFixFromBuilder(
+        builder, AnalysisOptionsFixKind.REPLACE_WITH_STRICT_RAW_TYPES,
+        args: [coveringNodePath[0].toString()]);
+  }
+
   /// Add a fix whose edits were built by the [builder] that has the given
   /// [kind]. If [args] are provided, they will be used to fill in the message
   /// for the fix.
@@ -191,6 +259,20 @@ class AnalysisOptionsFixGenerator {
     return offset;
   }
 
+  /// Returns whether the error is located within [map], covering the
+  /// [YamlScalar] node for [key].
+  bool _isErrorAtMapKey(YamlMap map, String key) {
+    var keyNode = map.nodes.keys
+        .whereType<YamlScalar>()
+        .firstWhereOrNull((k) => k.value == key);
+    if (keyNode == null) {
+      return false;
+    }
+    var keyOffset = keyNode.span.start.offset;
+    var keyLength = keyNode.span.end.offset - keyOffset;
+    return keyOffset == errorOffset && keyLength == errorLength;
+  }
+
   SourceRange _lines(int start, int end) {
     var startLocation = lineInfo.getLocation(start);
     var startOffset = lineInfo.getOffsetOfLine(startLocation.lineNumber - 1);
@@ -199,6 +281,53 @@ class AnalysisOptionsFixGenerator {
         math.min(endLocation.lineNumber, lineInfo.lineCount - 1));
     return SourceRange(startOffset, endOffset - startOffset);
   }
+
+  /// Replaces a 'strong-mode' entry keyed to [strongModeKey] with a 'language'
+  /// entry with [languageKey] and [languageValue].
+  ///
+  /// 'strong-mode' and 'language' are each maps which can be found under the
+  /// top-level 'analyzer' map. 'strong-mode' (given as [strongModeMap]) must
+  /// already be present under the 'analyzer' map (given as [analyzerMap]).
+  void _replaceStrongModeEntryWithLanguageEntry(
+    YamlFileEditBuilder builder,
+    List<YamlNode> coveringNodePath,
+    YamlMap analyzerMap,
+    YamlMap strongModeMap, {
+    required String strongModeKey,
+    required String languageKey,
+    required Object? languageValue,
+  }) {
+    var yamlEditor = YamlEditor(content);
+    // If 'language' does not exist yet under 'analyzer', create it.
+    if (analyzerMap['language'] == null) {
+      yamlEditor.update(['analyzer', 'language'], {languageKey: languageValue});
+    } else {
+      yamlEditor.update(['analyzer', 'language', languageKey], languageValue);
+    }
+    var languageEdit = yamlEditor.edits.single;
+    builder.addSimpleReplacement(
+        SourceRange(languageEdit.offset, languageEdit.length),
+        languageEdit.replacement);
+
+    // If `strongModeKey` is the only entry under 'strong-mode', then remove
+    // the entire 'strong-mode' entry.
+    if (strongModeMap.length == 1) {
+      yamlEditor.remove(['analyzer', 'strong-mode']);
+    } else {
+      yamlEditor.remove(['analyzer', 'strong-mode', strongModeKey]);
+    }
+    var strongModeEdit = yamlEditor.edits[1];
+    int strongModeEditOffset;
+    if (strongModeEdit.offset > languageEdit.offset) {
+      strongModeEditOffset = strongModeEdit.offset -
+          (languageEdit.replacement.length - languageEdit.length);
+    } else {
+      strongModeEditOffset = strongModeEdit.offset;
+    }
+    builder.addSimpleReplacement(
+        SourceRange(strongModeEditOffset, strongModeEdit.length),
+        strongModeEdit.replacement);
+  }
 }
 
 class _NonDartChangeWorkspace implements ChangeWorkspace {

pkg/analysis_server/pubspec.yaml

@@ -29,6 +29,7 @@ dependencies:
   path: any
   watcher: any
   yaml: any
+  yaml_edit: any
 
 dev_dependencies:
   analyzer_utilities:

pkg/analysis_server/test/abstract_context.dart

@@ -66,6 +66,10 @@ class AbstractContextTest with ResourceProviderMixin {
 
   Future<AnalysisSession> get session => sessionFor(testPackageRootPath);
 
+  /// The path for `analysis_options.yaml` in [testPackageRootPath].
+  String get testAnalysisOptionsPath =>
+      convertPath('$testPackageRootPath/analysis_options.yaml');
+
   String? get testPackageLanguageVersion => latestLanguageVersion;
 
   String get testPackageLibPath => '$testPackageRootPath/lib';

pkg/analysis_server/test/domain_completion_test.dart

@@ -43,17 +43,13 @@ void main() {
 /// TODO(scheglov) this is duplicate
 class AnalysisOptionsFileConfig {
   final List<String> experiments;
-  final bool implicitCasts;
-  final bool implicitDynamic;
   final List<String> lints;
   final bool strictCasts;
   final bool strictInference;
   final bool strictRawTypes;
 
   AnalysisOptionsFileConfig({
     this.experiments = const [],
-    this.implicitCasts = true,
-    this.implicitDynamic = true,
     this.lints = const [],
     this.strictCasts = false,
     this.strictInference = false,
@@ -72,9 +68,6 @@ class AnalysisOptionsFileConfig {
     buffer.writeln('    strict-casts: $strictCasts');
     buffer.writeln('    strict-inference: $strictInference');
     buffer.writeln('    strict-raw-types: $strictRawTypes');
-    buffer.writeln('  strong-mode:');
-    buffer.writeln('    implicit-casts: $implicitCasts');
-    buffer.writeln('    implicit-dynamic: $implicitDynamic');
 
     buffer.writeln('linter:');
     buffer.writeln('  rules:');

pkg/analysis_server/test/src/services/correction/fix/analysis_options/replace_with_strict_casts_test.dart

@@ -0,0 +1,163 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ReplaceWithStrictCastsTest);
+  });
+}
+
+@reflectiveTest
+class ReplaceWithStrictCastsTest extends AnalysisOptionsFixTest {
+  Future<void> test_hasLanguage() async {
+    await assertHasFix('''
+analyzer:
+  language:
+    strict-inference: true
+  strong-mode:
+    implicit-casts: false
+''', '''
+analyzer:
+  language:
+    strict-casts: true
+    strict-inference: true
+''');
+  }
+
+  Future<void> test_hasLanguage_isAfter() async {
+    await assertHasFix('''
+analyzer:
+  strong-mode:
+    implicit-casts: false
+  language:
+    strict-inference: true
+''', '''
+analyzer:
+  language:
+    strict-casts: true
+    strict-inference: true
+''');
+  }
+
+  Future<void> test_hasStrictCastsFalse() async {
+    await assertHasFix('''
+analyzer:
+  language:
+    strict-casts: false
+  strong-mode:
+    implicit-casts: false
+''', '''
+analyzer:
+  language:
+    strict-casts: true
+''');
+  }
+
+  Future<void> test_hasStrictCastsTrue() async {
+    await assertHasFix('''
+analyzer:
+  language:
+    strict-casts: true
+  strong-mode:
+    implicit-casts: false
+''', '''
+analyzer:
+  language:
+    strict-casts: true
+''');
+  }
+
+  Future<void> test_noLanguage() async {
+    await assertHasFix('''
+analyzer:
+  strong-mode:
+    implicit-casts: false
+''', '''
+analyzer:
+  language:
+    strict-casts: true
+''');
+  }
+
+  Future<void> test_noLanguage_analyzerHasOtherEntries() async {
+    await assertHasFix('''
+analyzer:
+  errors:
+    unused_import: ignore
+  strong-mode:
+    implicit-casts: false
+''', '''
+analyzer:
+  errors:
+    unused_import: ignore
+  language:
+    strict-casts: true
+''');
+  }
+
+  Future<void> test_noLanguage_analyzerHasOtherEntriesAfter() async {
+    await assertHasFix('''
+analyzer:
+  strong-mode:
+    implicit-casts: false
+  errors:
+    unused_import: ignore
+''', '''
+analyzer:
+  errors:
+    unused_import: ignore
+  language:
+    strict-casts: true
+''');
+  }
+
+  Future<void> test_noLanguage_hasOtherStrongModeEntry() async {
+    await assertHasFix('''
+analyzer:
+  strong-mode:
+    implicit-casts: false
+    implicit-dynamic: false
+''', '''
+analyzer:
+  language:
+    strict-casts: true
+  strong-mode:
+    implicit-dynamic: false
+''', errorFilter: (error) => error.message.contains('implicit-casts'));
+  }
+
+  Future<void> test_noLanguage_implicitCastsHasComment() async {
+    await assertHasFix('''
+analyzer:
+  strong-mode:
+    # No implicit casts
+    implicit-casts: false
+''', '''
+analyzer:
+  language:
+    strict-casts: true
+''');
+  }
+
+  Future<void> test_noLanguage_strongModeHasComment() async {
+    // TODO(srawlins): This is unfortunate; it would be better to remove the
+    // comment. But we leave this assertion as is to show at least the file is
+    // not corrupted.
+    await assertHasFix('''
+analyzer:
+  # Strong mode
+  strong-mode:
+    implicit-casts: false
+''', '''
+analyzer:
+  # Strong mode
+  language:
+    strict-casts: true
+''');
+  }
+}