Version 2.11.0-157.0.dev

Merge commit 'd966206c6defa2b52be74642318c780283f24bfb' into 'dev'

Author: Dart CI

.dart_tool/package_config.json

@@ -11,7 +11,7 @@
     "constraint, update this by running tools/generate_package_config.dart."
   ],
   "configVersion": 2,
-  "generated": "2020-08-18T15:38:52.410101",
+  "generated": "2020-09-18T09:56:27.880444",
   "generator": "tools/generate_package_config.dart",
   "packages": [
     {
@@ -184,7 +184,7 @@
       "name": "dart2js_info",
       "rootUri": "../third_party/pkg/dart2js_info",
       "packageUri": "lib/",
-      "languageVersion": "2.0"
+      "languageVersion": "2.3"
     },
     {
       "name": "dart2js_tools",
@@ -207,8 +207,7 @@
     {
       "name": "dart_style",
       "rootUri": "../third_party/pkg_tested/dart_style",
-      "packageUri": "lib/",
-      "languageVersion": "2.7"
+      "packageUri": "lib/"
     },
     {
       "name": "dartdev",
@@ -348,8 +347,7 @@
     {
       "name": "js_runtime",
       "rootUri": "../sdk/lib/_internal/js_runtime",
-      "packageUri": "lib/",
-      "languageVersion": "2.10"
+      "packageUri": "lib/"
     },
     {
       "name": "json_rpc_2",
@@ -426,7 +424,7 @@
       "name": "native_stack_traces",
       "rootUri": "../pkg/native_stack_traces",
       "packageUri": "lib/",
-      "languageVersion": "2.8"
+      "languageVersion": "2.10"
     },
     {
       "name": "nnbd_migration",
@@ -484,8 +482,7 @@
     {
       "name": "pub",
       "rootUri": "../third_party/pkg/pub",
-      "packageUri": "lib/",
-      "languageVersion": "2.3"
+      "packageUri": "lib/"
     },
     {
       "name": "pub_semver",
@@ -508,8 +505,7 @@
     {
       "name": "sdk_library_metadata",
       "rootUri": "../sdk/lib/_internal/sdk_library_metadata",
-      "packageUri": "lib/",
-      "languageVersion": "2.10"
+      "packageUri": "lib/"
     },
     {
       "name": "shelf",

CHANGELOG.md

@@ -8,6 +8,12 @@
 
 ### Tools
 
+#### Dartanalyzer
+
+* Removed the `--use-fasta-parser`, `--preview-dart-2`, and
+  `--enable-assert-initializers` command line options. These options haven't
+  been supported in a while and were no-ops.
+
 #### Linter
 
 Updated the Linter to `0.1.119`, which includes:
@@ -55,7 +61,7 @@ Updated the Linter to `0.1.119`, which includes:
     deferred loading of types, pass `--no-defer-class-types`. See the original
     post on the [unsoundness in the deferred loading algorithm][].
 *   Enables a new sound deferred splitting algorithm. To explicitly disable
-    the new deferred splitting algorithm, pass `--no-new-deferred-split'.
+    the new deferred splitting algorithm, pass `--no-new-deferred-split`.
     See the original post on the
     [unsoundness in the deferred loading algorithm][].
 

DEPS

@@ -44,7 +44,7 @@ vars = {
   # co19 is a cipd package. Use update.sh in tests/co19[_2] to update these
   # hashes. It requires access to the dart-build-access group, which EngProd
   # has.
-  "co19_rev": "b7660861df12eb489243a591e45f251f8cf8c4a8",
+  "co19_rev": "da33ec472443aa14d969bf54b9adc3af71cb6382",
   "co19_2_rev": "e48b3090826cf40b8037648f19d211e8eab1b4b6",
 
   # The internal benchmarks to use. See go/dart-benchmarks-internal

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart

@@ -609,6 +609,11 @@ abstract class FlowAnalysis<Node, Statement extends Node, Expression, Variable,
   void parenthesizedExpression(
       Expression outerExpression, Expression innerExpression);
 
+  /// Attempt to promote [variable] to [type].  The client may use this to
+  /// ensure that a variable declaration of the form `var x = expr;` promotes
+  /// `x` to type `X&T` in the circumstance where the type of `expr` is `X&T`.
+  void promote(Variable variable, Type type);
+
   /// Retrieves the type that the [variable] is promoted to, if the [variable]
   /// is currently promoted.  Otherwise returns `null`.
   Type promotedType(Variable variable);
@@ -749,7 +754,12 @@ abstract class FlowAnalysis<Node, Statement extends Node, Expression, Variable,
 
   /// Register write of the given [variable] in the current state.
   /// [writtenType] should be the type of the value that was written.
-  void write(Variable variable, Type writtenType);
+  ///
+  /// This should also be used for the implicit write to a non-final variable in
+  /// its initializer, to ensure that the type is promoted to non-nullable if
+  /// necessary; in this case, [viaInitializer] should be `true`.
+  void write(Variable variable, Type writtenType,
+      {bool viaInitializer = false});
 }
 
 /// Alternate implementation of [FlowAnalysis] that prints out inputs and output
@@ -1054,6 +1064,11 @@ class FlowAnalysisDebug<Node, Statement extends Node, Expression, Variable,
             _wrapped.parenthesizedExpression(outerExpression, innerExpression));
   }
 
+  @override
+  void promote(Variable variable, Type type) {
+    _wrap('promote($variable, $type', () => _wrapped.promote(variable, type));
+  }
+
   @override
   Type promotedType(Variable variable) {
     return _wrap(
@@ -1156,9 +1171,12 @@ class FlowAnalysisDebug<Node, Statement extends Node, Expression, Variable,
   }
 
   @override
-  void write(Variable variable, Type writtenType) {
-    _wrap('write($variable, $writtenType)',
-        () => _wrapped.write(variable, writtenType));
+  void write(Variable variable, Type writtenType,
+      {bool viaInitializer = false}) {
+    _wrap(
+        'write($variable, $writtenType, viaInitializer: $viaInitializer)',
+        () => _wrapped.write(variable, writtenType,
+            viaInitializer: viaInitializer));
   }
 
   T _wrap<T>(String description, T callback(),
@@ -1770,11 +1788,6 @@ abstract class TypeOperations<Variable, Type> {
           List<Type> newPromotedTypes) =>
       false;
 
-  /// Return `true` if the [variable] is a local variable (not a formal
-  /// parameter), and it has no declared type (no explicit type, and not
-  /// initializer).
-  bool isLocalVariableWithoutDeclaredType(Variable variable);
-
   /// Determines whether the given [type] is equivalent to the `Never` type.
   ///
   /// A type is equivalent to `Never` if it:
@@ -1985,11 +1998,6 @@ class VariableModel<Variable, Type> {
           promotedTypes, tested, true, false, writeCaptured);
     }
 
-    if (_isPromotableViaInitialization(typeOperations, variable)) {
-      return new VariableModel<Variable, Type>(
-          [writtenType], tested, true, false, writeCaptured);
-    }
-
     List<Type> newPromotedTypes = _demoteViaAssignment(
       writtenType,
       typeOperations,
@@ -2041,26 +2049,6 @@ class VariableModel<Variable, Type> {
     }
   }
 
-  /// We say that a variable `x` is promotable via initialization given
-  /// variable model `VM` if `x` is a local variable (not a formal parameter)
-  /// and:
-  /// * VM = VariableModel(declared, promoted, tested,
-  ///                      assigned, unassigned, captured)
-  /// * and `captured` is false
-  /// * and `promoted` is empty
-  /// * and `x` is declared with no explicit type and no initializer
-  /// * and `assigned` is false and `unassigned` is true
-  bool _isPromotableViaInitialization<Variable>(
-    TypeOperations<Variable, Type> typeOperations,
-    Variable variable,
-  ) {
-    return !writeCaptured &&
-        !assigned &&
-        unassigned &&
-        promotedTypes == null &&
-        typeOperations.isLocalVariableWithoutDeclaredType(variable);
-  }
-
   /// Determines whether a variable with the given [promotedTypes] should be
   /// promoted to [writtenType] based on types of interest.  If it should,
   /// returns an updated promotion chain; otherwise returns [promotedTypes]
@@ -2902,6 +2890,12 @@ class _FlowAnalysisImpl<Node, Statement extends Node, Expression, Variable,
     }
   }
 
+  @override
+  void promote(Variable variable, Type type) {
+    _current =
+        _current.tryPromoteForTypeCheck(typeOperations, variable, type).ifTrue;
+  }
+
   @override
   Type promotedType(Variable variable) {
     return _current.infoFor(variable).promotedTypes?.last;
@@ -3055,11 +3049,14 @@ class _FlowAnalysisImpl<Node, Statement extends Node, Expression, Variable,
   }
 
   @override
-  void write(Variable variable, Type writtenType) {
-    assert(
-        _assignedVariables._anywhere._written.contains(variable),
-        "Variable is written to, but was not included in "
-        "_variablesWrittenAnywhere: $variable");
+  void write(Variable variable, Type writtenType,
+      {bool viaInitializer = false}) {
+    if (!viaInitializer) {
+      assert(
+          _assignedVariables._anywhere._written.contains(variable),
+          "Variable is written to, but was not included in "
+          "_variablesWrittenAnywhere: $variable");
+    }
     _current = _current.write(variable, writtenType, typeOperations);
   }
 

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -4012,6 +4012,32 @@ Message _withArgumentsFinalFieldWithoutInitializer(String name) {
       arguments: {'name': name});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String
+            name)> templateFinalNotAssignedError = const Template<
+        Message Function(String name)>(
+    messageTemplate:
+        r"""Final variable '#name' must be assigned before it can be used.""",
+    withArguments: _withArgumentsFinalNotAssignedError);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)> codeFinalNotAssignedError =
+    const Code<Message Function(String name)>(
+        "FinalNotAssignedError", templateFinalNotAssignedError,
+        analyzerCodes: <String>["READ_POTENTIALLY_UNASSIGNED_FINAL"]);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsFinalNotAssignedError(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeFinalNotAssignedError,
+      message:
+          """Final variable '${name}' must be assigned before it can be used.""",
+      arguments: {'name': name});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeForInLoopExactlyOneVariable =
     messageForInLoopExactlyOneVariable;

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -1443,6 +1443,54 @@ main() {
       });
     });
 
+    test('promote promotes to a subtype and sets type of interest', () {
+      var h = _Harness();
+      var x = h.addVar('x', 'num?');
+      h.assignedVariables((vars) {
+        vars.write(x);
+      });
+      h.run((flow) {
+        flow.declare(x, true);
+        expect(flow.promotedType(x), isNull);
+        flow.promote(x, _Type('num'));
+        expect(flow.promotedType(x).type, 'num');
+        // Check that it's a type of interest by promoting and de-promoting.
+        h.if_(h.isType(h.variableRead(x), 'int'), () {
+          expect(flow.promotedType(x).type, 'int');
+          flow.write(x, _Type('num'));
+          expect(flow.promotedType(x).type, 'num');
+        });
+      });
+    });
+
+    test('promote does not promote to a non-subtype', () {
+      var h = _Harness();
+      var x = h.addVar('x', 'num?');
+      h.run((flow) {
+        flow.declare(x, true);
+        expect(flow.promotedType(x), isNull);
+        flow.promote(x, _Type('String'));
+        expect(flow.promotedType(x), isNull);
+      });
+    });
+
+    test('promote does not promote if variable is write-captured', () {
+      var h = _Harness();
+      var x = h.addVar('x', 'num?');
+      var functionNode = _Node();
+      h.assignedVariables(
+          (vars) => vars.function(functionNode, () => vars.write(x)));
+      h.run((flow) {
+        flow.declare(x, true);
+        expect(flow.promotedType(x), isNull);
+        flow.functionExpression_begin(functionNode);
+        flow.write(x, _Type('num'));
+        flow.functionExpression_end();
+        flow.promote(x, _Type('num'));
+        expect(flow.promotedType(x), isNull);
+      });
+    });
+
     test('promotedType handles not-yet-seen variables', () {
       // Note: this is needed for error recovery in the analyzer.
       var h = _Harness();
@@ -2658,21 +2706,6 @@ main() {
           });
         });
       });
-
-      test('promote via initialization', () {
-        var h = _Harness();
-        var x = _Var('x', null, isLocalVariableWithoutDeclaredType: true);
-
-        var s1 = FlowModel<_Var, _Type>(true).declare(x, false);
-        expect(s1.variableInfo, {
-          x: _matchVariableModel(chain: null),
-        });
-
-        var s2 = s1.write(x, _Type('int'), h);
-        expect(s2.variableInfo, {
-          x: _matchVariableModel(chain: ['int']),
-        });
-      });
     });
 
     group('demotion, to NonNull', () {
@@ -3789,11 +3822,6 @@ class _Harness extends TypeOperations<_Var, _Type> {
     if_(isNotType(variableRead(variable), type), ifTrue);
   }
 
-  @override
-  bool isLocalVariableWithoutDeclaredType(_Var variable) {
-    return variable.isLocalVariableWithoutDeclaredType;
-  }
-
   @override
   bool isNever(_Type type) {
     return type.type == 'Never';
@@ -3956,13 +3984,8 @@ class _Type {
 class _Var {
   final String name;
   final _Type type;
-  final bool isLocalVariableWithoutDeclaredType;
 
-  _Var(
-    this.name,
-    this.type, {
-    this.isLocalVariableWithoutDeclaredType = false,
-  });
+  _Var(this.name, this.type);
 
   @override
   String toString() => '$type $name';