Version 2.10.0-136.0.dev

Merge commit '0eec9ee53c4306abea1733b3b5cc2bfb57cbe380' into 'dev'

Author: Dart CI

pkg/_fe_analyzer_shared/test/flow_analysis/type_promotion/data/bug42653.dart

@@ -0,0 +1,39 @@
+// Copyright (c) 2020, 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.
+
+void forEachStatement(Object x) {
+  if (x is int) {
+    /*int*/ x;
+    for (x in [0]) {
+      /*int*/ x;
+    }
+  }
+}
+
+forEachElementInListLiteral(Object x) {
+  if (x is int) {
+    /*int*/ x;
+    return [
+      for (x in [0]) /*int*/ x
+    ];
+  }
+}
+
+forEachElementInMapLiteral(Object x) {
+  if (x is int) {
+    /*int*/ x;
+    return {
+      for (x in [0]) /*int*/ x: /*int*/ x
+    };
+  }
+}
+
+forEachElementInSetLiteral(Object x) {
+  if (x is int) {
+    /*int*/ x;
+    return {
+      for (x in [0]) /*int*/ x
+    };
+  }
+}

pkg/analysis_server/lib/lsp_protocol/protocol_generated.dart

@@ -4938,8 +4938,8 @@ class CreateFile implements ToJsonable {
           reporter.reportError('must not be null');
           return false;
         }
-        if (!(obj['kind'] is String)) {
-          reporter.reportError('must be of type String');
+        if (!(obj['kind'] == 'create')) {
+          reporter.reportError('must be the literal \'create\'');
           return false;
         }
       } finally {
@@ -5963,8 +5963,8 @@ class DeleteFile implements ToJsonable {
           reporter.reportError('must not be null');
           return false;
         }
-        if (!(obj['kind'] is String)) {
-          reporter.reportError('must be of type String');
+        if (!(obj['kind'] == 'delete')) {
+          reporter.reportError('must be the literal \'delete\'');
           return false;
         }
       } finally {
@@ -13198,7 +13198,10 @@ class InitializeParams implements WorkDoneProgressParams, ToJsonable {
     final capabilities = json['capabilities'] != null
         ? ClientCapabilities.fromJson(json['capabilities'])
         : null;
-    final trace = json['trace'];
+    final trace = const {null, 'off', 'messages', 'verbose'}
+            .contains(json['trace'])
+        ? json['trace']
+        : throw '''${json['trace']} was not one of (null, 'off', 'messages', 'verbose')''';
     final workspaceFolders = json['workspaceFolders']
         ?.map((item) => item != null ? WorkspaceFolder.fromJson(item) : null)
         ?.cast<WorkspaceFolder>()
@@ -13363,8 +13366,12 @@ class InitializeParams implements WorkDoneProgressParams, ToJsonable {
       }
       reporter.push('trace');
       try {
-        if (obj['trace'] != null && !(obj['trace'] is String)) {
-          reporter.reportError('must be of type String');
+        if (obj['trace'] != null &&
+            !((obj['trace'] == 'off' ||
+                obj['trace'] == 'messages' ||
+                obj['trace'] == 'verbose'))) {
+          reporter.reportError(
+              'must be one of the literals \'off\', \'messages\', \'verbose\'');
           return false;
         }
       } finally {
@@ -16647,8 +16654,8 @@ class RenameFile implements ToJsonable {
           reporter.reportError('must not be null');
           return false;
         }
-        if (!(obj['kind'] is String)) {
-          reporter.reportError('must be of type String');
+        if (!(obj['kind'] == 'rename')) {
+          reporter.reportError('must be the literal \'rename\'');
           return false;
         }
       } finally {
@@ -23813,8 +23820,8 @@ class WorkDoneProgressBegin implements ToJsonable {
           reporter.reportError('must not be null');
           return false;
         }
-        if (!(obj['kind'] is String)) {
-          reporter.reportError('must be of type String');
+        if (!(obj['kind'] == 'begin')) {
+          reporter.reportError('must be the literal \'begin\'');
           return false;
         }
       } finally {
@@ -24090,8 +24097,8 @@ class WorkDoneProgressEnd implements ToJsonable {
           reporter.reportError('must not be null');
           return false;
         }
-        if (!(obj['kind'] is String)) {
-          reporter.reportError('must be of type String');
+        if (!(obj['kind'] == 'end')) {
+          reporter.reportError('must be the literal \'end\'');
           return false;
         }
       } finally {
@@ -24464,8 +24471,8 @@ class WorkDoneProgressReport implements ToJsonable {
           reporter.reportError('must not be null');
           return false;
         }
-        if (!(obj['kind'] is String)) {
-          reporter.reportError('must be of type String');
+        if (!(obj['kind'] == 'report')) {
+          reporter.reportError('must be the literal \'report\'');
           return false;
         }
       } finally {

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

@@ -0,0 +1,106 @@
+// Copyright (c) 2020, 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:analysis_server/src/services/correction/dart/abstract_producer.dart';
+import 'package:analysis_server/src/services/correction/fix.dart';
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/nullability_suffix.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
+import 'package:analyzer_plugin/utilities/range_factory.dart';
+
+class MakeVariableNullable extends CorrectionProducer {
+  /// The name of the variable whose type is to be made nullable.
+  String _variableName;
+
+  @override
+  List<Object> get fixArguments => [_variableName];
+
+  @override
+  FixKind get fixKind => DartFixKind.MAKE_VARIABLE_NULLABLE;
+
+  @override
+  Future<void> compute(ChangeBuilder builder) async {
+    var node = coveredNode;
+    var parent = node?.parent;
+    if (unit.featureSet.isEnabled(Feature.non_nullable) &&
+        parent is AssignmentExpression &&
+        parent.rightHandSide == node) {
+      var leftHandSide = parent.leftHandSide;
+      if (leftHandSide is SimpleIdentifier) {
+        var element = leftHandSide.staticElement;
+        if (element is LocalVariableElement) {
+          var oldType = element.type;
+          var newType = (node as Expression).staticType;
+          if (node is NullLiteral) {
+            newType = (oldType as InterfaceTypeImpl)
+                .withNullability(NullabilitySuffix.question);
+          } else if (!typeSystem.isAssignableTo(
+              oldType, typeSystem.promoteToNonNull(newType))) {
+            return;
+          }
+          var declarationList =
+              _findDeclaration(element, parent.thisOrAncestorOfType<Block>());
+          if (declarationList == null || declarationList.variables.length > 1) {
+            return;
+          }
+          var variable = declarationList.variables[0];
+          _variableName = variable.name.name;
+          await builder.addDartFileEdit(file, (builder) {
+            var keyword = declarationList.keyword;
+            if (keyword != null && keyword.type == Keyword.VAR) {
+              builder.addReplacement(range.token(keyword), (builder) {
+                builder.writeType(newType);
+              });
+            } else if (keyword == null) {
+              if (declarationList.type == null) {
+                builder.addInsertion(variable.offset, (builder) {
+                  builder.writeType(newType);
+                  builder.write(' ');
+                });
+              } else {
+                builder.addSimpleInsertion(declarationList.type.end, '?');
+              }
+            }
+          });
+        }
+      }
+    }
+  }
+
+  /// Return the list of variable declarations containing the declaration of the
+  /// given [variable] that is located in the given [block] or in a surrounding
+  /// block. Return `null` if the declaration can't be found.
+  VariableDeclarationList _findDeclaration(
+      LocalVariableElement variable, Block block) {
+    if (variable == null) {
+      return null;
+    }
+    var currentBlock = block;
+    while (currentBlock != null) {
+      for (var statement in block.statements) {
+        if (statement is VariableDeclarationStatement) {
+          var variableList = statement.variables;
+          if (variableList != null) {
+            var variables = variableList.variables;
+            for (var declaration in variables) {
+              if (declaration.declaredElement == variable) {
+                return variableList;
+              }
+            }
+          }
+        }
+      }
+      currentBlock = currentBlock.parent.thisOrAncestorOfType<Block>();
+    }
+    return null;
+  }
+
+  /// Return an instance of this class. Used as a tear-off in `FixProcessor`.
+  static MakeVariableNullable newInstance() => MakeVariableNullable();
+}

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

@@ -323,6 +323,8 @@ class DartFixKind {
       'Move type arguments to after class name');
   static const MAKE_VARIABLE_NOT_FINAL = FixKind(
       'dart.fix.makeVariableNotFinal', 50, "Make variable '{0}' not final");
+  static const MAKE_VARIABLE_NULLABLE =
+      FixKind('dart.fix.makeVariableNullable', 50, "Make '{0}' nullable");
   static const ORGANIZE_IMPORTS =
       FixKind('dart.fix.organize.imports', 50, 'Organize Imports');
   static const QUALIFY_REFERENCE =

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

@@ -80,6 +80,7 @@ import 'package:analysis_server/src/services/correction/dart/make_field_not_fina
 import 'package:analysis_server/src/services/correction/dart/make_final.dart';
 import 'package:analysis_server/src/services/correction/dart/make_return_type_nullable.dart';
 import 'package:analysis_server/src/services/correction/dart/make_variable_not_final.dart';
+import 'package:analysis_server/src/services/correction/dart/make_variable_nullable.dart';
 import 'package:analysis_server/src/services/correction/dart/move_type_arguments_to_class.dart';
 import 'package:analysis_server/src/services/correction/dart/organize_imports.dart';
 import 'package:analysis_server/src/services/correction/dart/qualify_reference.dart';
@@ -716,6 +717,7 @@ class FixProcessor extends BaseProcessor {
       AddExplicitCast.newInstance,
       AddNullCheck.newInstance,
       ChangeTypeAnnotation.newInstance,
+      MakeVariableNullable.newInstance,
     ],
     CompileTimeErrorCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION: [
       RemoveParenthesesInGetterInvocation.newInstance,

pkg/analysis_server/test/src/services/correction/fix/make_variable_nullable_test.dart

@@ -0,0 +1,111 @@
+// Copyright (c) 2020, 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:analysis_server/src/services/correction/fix.dart';
+import 'package:analyzer/src/dart/analysis/experiments.dart';
+import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'fix_processor.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(MakeVariableNullableTest);
+  });
+}
+
+@reflectiveTest
+class MakeVariableNullableTest extends FixProcessorTest {
+  @override
+  List<String> get experiments => [EnableString.non_nullable];
+
+  @override
+  FixKind get kind => DartFixKind.MAKE_VARIABLE_NULLABLE;
+
+  Future<void> test_lhsNotIdentifier() async {
+    await resolveTestUnit('''
+void f(C c) {
+  c.s = null;
+}
+class C {
+  String s = '';
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_lhsNotLocalVariable() async {
+    await resolveTestUnit('''
+var s = '';
+void f() {
+  s = null;
+  print(s);
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_multipleVariables() async {
+    await resolveTestUnit('''
+void f() {
+  var s = '', t = '';
+  s = null;
+  print(s);
+  print(t);
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_noKeywordOrType() async {
+    await resolveTestUnit('''
+void f() {
+  late s = '';
+  s = null;
+  print(s);
+}
+''');
+    await assertHasFix('''
+void f() {
+  late String? s = '';
+  s = null;
+  print(s);
+}
+''');
+  }
+
+  Future<void> test_type() async {
+    await resolveTestUnit('''
+void f() {
+  String s = '';
+  s = null;
+  print(s);
+}
+''');
+    await assertHasFix('''
+void f() {
+  String? s = '';
+  s = null;
+  print(s);
+}
+''');
+  }
+
+  Future<void> test_var() async {
+    await resolveTestUnit('''
+void f() {
+  var s = '';
+  s = null;
+  print(s);
+}
+''');
+    await assertHasFix('''
+void f() {
+  String? s = '';
+  s = null;
+  print(s);
+}
+''');
+  }
+}

pkg/analysis_server/test/src/services/correction/fix/test_all.dart

@@ -94,6 +94,7 @@ import 'make_field_not_final_test.dart' as make_field_not_final;
 import 'make_final_test.dart' as make_final;
 import 'make_return_type_nullable_test.dart' as make_return_type_nullable;
 import 'make_variable_not_final_test.dart' as make_variable_not_final;
+import 'make_variable_nullable_test.dart' as make_variable_nullable;
 import 'move_type_arguments_to_class_test.dart' as move_type_arguments_to_class;
 import 'organize_imports_test.dart' as organize_imports;
 import 'qualify_reference_test.dart' as qualify_reference;
@@ -249,6 +250,7 @@ void main() {
     make_final.main();
     make_return_type_nullable.main();
     make_variable_not_final.main();
+    make_variable_nullable.main();
     move_type_arguments_to_class.main();
     organize_imports.main();
     qualify_reference.main();