Version 2.10.0-33.0.dev

Merge commit '87027c97a12a9926c2af8770a3d2a5cebc1767f3' into 'dev'

Author: Dart CI

pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart

@@ -18,6 +18,7 @@ import 'package:analyzer/src/dart/resolver/resolution_result.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/error/nullable_dereference_verifier.dart';
+import 'package:analyzer/src/generated/migration.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/task/strong/checker.dart';
 import 'package:meta/meta.dart';
@@ -46,6 +47,10 @@ class AssignmentExpressionResolver {
 
   bool get _isNonNullableByDefault => _typeSystem.isNonNullableByDefault;
 
+  MigrationResolutionHooks get _migrationResolutionHooks {
+    return _resolver.migrationResolutionHooks;
+  }
+
   NullableDereferenceVerifier get _nullableDereferenceVerifier =>
       _resolver.nullableDereferenceVerifier;
 
@@ -57,10 +62,22 @@ class AssignmentExpressionResolver {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
 
+    // Case `id = e`.
+    // Consider an assignment of the form `id = e`, where `id` is an identifier.
+    if (left is SimpleIdentifier) {
+      var leftLookup = _resolver.nameScope.lookup2(left.name);
+      // When the lexical lookup yields a local variable `v`.
+      var leftGetter = leftLookup.getter;
+      if (leftGetter is VariableElement) {
+        _resolve_SimpleIdentifier_LocalVariable(node, left, leftGetter, right);
+        return;
+      }
+    }
+
     left?.accept(_resolver);
     left = node.leftHandSide;
 
-    var leftLocalVariable = _flowAnalysis?.assignmentExpression(node);
+    _flowAnalysis?.assignmentExpression(node);
 
     TokenType operator = node.operator.type;
     if (operator == TokenType.EQ ||
@@ -76,12 +93,7 @@ class AssignmentExpressionResolver {
     _resolve1(node);
     _resolve2(node);
 
-    _flowAnalysis?.assignmentExpression_afterRight(
-        node,
-        leftLocalVariable,
-        operator == TokenType.QUESTION_QUESTION_EQ
-            ? node.rightHandSide.staticType
-            : node.staticType);
+    _flowAnalysis?.assignmentExpression_afterRight(node);
   }
 
   /// Set the static type of [node] to be the least upper bound of the static
@@ -180,6 +192,32 @@ class AssignmentExpressionResolver {
     return type;
   }
 
+  /// Record that the static type of the given node is the given type.
+  ///
+  /// @param expression the node whose type is to be recorded
+  /// @param type the static type of the node
+  ///
+  /// TODO(scheglov) this is duplication
+  void _recordStaticType(Expression expression, DartType type) {
+    if (_resolver.migrationResolutionHooks != null) {
+      // TODO(scheglov) type cannot be null
+      type = _migrationResolutionHooks.modifyExpressionType(
+        expression,
+        type ?? DynamicTypeImpl.instance,
+      );
+    }
+
+    // TODO(scheglov) type cannot be null
+    if (type == null) {
+      expression.staticType = DynamicTypeImpl.instance;
+    } else {
+      expression.staticType = type;
+      if (_typeSystem.isBottom(type)) {
+        _flowAnalysis?.flow?.handleExit();
+      }
+    }
+  }
+
   void _resolve1(AssignmentExpressionImpl node) {
     Token operator = node.operator;
     TokenType operatorType = operator.type;
@@ -290,6 +328,47 @@ class AssignmentExpressionResolver {
     _resolver.nullShortingTermination(node);
   }
 
+  void _resolve_SimpleIdentifier_LocalVariable(
+    AssignmentExpressionImpl node,
+    SimpleIdentifier left,
+    VariableElement leftElement,
+    Expression right,
+  ) {
+    left.staticElement = leftElement;
+
+    var leftType = _resolver.localVariableTypeProvider.getType(left);
+    // TODO(scheglov) Set the type only when `operator != TokenType.EQ`.
+    _recordStaticType(left, leftType);
+
+    var operator = node.operator.type;
+    if (operator != TokenType.EQ) {
+      _resolver.checkReadOfNotAssignedLocalVariable(left);
+    }
+
+    if (operator == TokenType.EQ ||
+        operator == TokenType.QUESTION_QUESTION_EQ) {
+      InferenceContext.setType(right, leftType);
+    }
+
+    var flow = _flowAnalysis?.flow;
+    if (flow != null && operator == TokenType.QUESTION_QUESTION_EQ) {
+      flow.ifNullExpression_rightBegin(left);
+    }
+
+    right?.accept(_resolver);
+    right = node.rightHandSide;
+
+    _resolve1(node);
+    _resolve2(node);
+
+    if (flow != null) {
+      flow.write(leftElement, node.staticType);
+      if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
+        flow.ifNullExpression_end();
+      }
+    }
+  }
+
   /// If the given [type] is a type parameter, resolve it to the type that
   /// should be used when looking up members. Otherwise, return the original
   /// type.

pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart

@@ -77,30 +77,16 @@ class FlowAnalysisHelper {
     flow.asExpression_end(expression, typeAnnotation.type);
   }
 
-  VariableElement assignmentExpression(AssignmentExpression node) {
+  void assignmentExpression(AssignmentExpression node) {
     if (flow == null) return null;
 
     if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
       flow.ifNullExpression_rightBegin(node.leftHandSide);
     }
-
-    var left = node.leftHandSide;
-
-    if (left is SimpleIdentifier) {
-      var element = left.staticElement;
-      if (element is VariableElement) {
-        return element;
-      }
-    }
-
-    return null;
   }
 
-  void assignmentExpression_afterRight(AssignmentExpression node,
-      VariableElement localElement, DartType writtenType) {
-    if (localElement != null) {
-      flow.write(localElement, writtenType);
-    }
+  void assignmentExpression_afterRight(AssignmentExpression node) {
+    if (flow == null) return null;
 
     if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
       flow.ifNullExpression_end();

pkg/analyzer/lib/src/generated/resolver.dart

@@ -153,6 +153,8 @@ class ResolverVisitor extends ScopedVisitor {
 
   final MigratableAstInfoProvider _migratableAstInfoProvider;
 
+  final MigrationResolutionHooks migrationResolutionHooks;
+
   /// Helper for checking expression that should have the `bool` type.
   BoolExpressionVerifier boolExpressionVerifier;
 
@@ -290,6 +292,7 @@ class ResolverVisitor extends ScopedVisitor {
       this._migratableAstInfoProvider,
       MigrationResolutionHooks migrationResolutionHooks)
       : _featureSet = featureSet,
+        migrationResolutionHooks = migrationResolutionHooks,
         super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     _promoteManager = TypePromotionManager(typeSystem);
@@ -429,6 +432,26 @@ class ResolverVisitor extends ScopedVisitor {
     }
   }
 
+  void checkReadOfNotAssignedLocalVariable(SimpleIdentifier node) {
+    if (_flowAnalysis != null) {
+      if (_flowAnalysis.isPotentiallyNonNullableLocalReadBeforeWrite(node)) {
+        errorReporter.reportErrorForNode(
+          CompileTimeErrorCode
+              .NOT_ASSIGNED_POTENTIALLY_NON_NULLABLE_LOCAL_VARIABLE,
+          node,
+          [node.name],
+        );
+      }
+      if (_flowAnalysis.isReadOfDefinitelyUnassignedLateLocal(node)) {
+        errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.DEFINITELY_UNASSIGNED_LATE_LOCAL_VARIABLE,
+          node,
+          [node.name],
+        );
+      }
+    }
+  }
+
   void checkUnreachableNode(AstNode node) {
     nullSafetyDeadCodeVerifier.visitNode(node);
   }
@@ -1533,23 +1556,7 @@ class ResolverVisitor extends ScopedVisitor {
       return;
     }
 
-    if (_flowAnalysis != null) {
-      if (_flowAnalysis.isPotentiallyNonNullableLocalReadBeforeWrite(node)) {
-        errorReporter.reportErrorForNode(
-          CompileTimeErrorCode
-              .NOT_ASSIGNED_POTENTIALLY_NON_NULLABLE_LOCAL_VARIABLE,
-          node,
-          [node.name],
-        );
-      }
-      if (_flowAnalysis.isReadOfDefinitelyUnassignedLateLocal(node)) {
-        errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.DEFINITELY_UNASSIGNED_LATE_LOCAL_VARIABLE,
-          node,
-          [node.name],
-        );
-      }
-    }
+    checkReadOfNotAssignedLocalVariable(node);
 
     super.visitSimpleIdentifier(node);
   }

pkg/analyzer/lib/src/generated/static_type_analyzer.dart

@@ -102,14 +102,20 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
   ///
   /// @param expression the node whose type is to be recorded
   /// @param type the static type of the node
+  ///
+  /// TODO(scheglov) this is duplication
   void recordStaticType(Expression expression, DartType type) {
     if (_migrationResolutionHooks != null) {
+      // TODO(scheglov) type cannot be null
       type = _migrationResolutionHooks.modifyExpressionType(
-          expression, type ?? _dynamicType);
+        expression,
+        type ?? DynamicTypeImpl.instance,
+      );
     }
 
+    // TODO(scheglov) type cannot be null
     if (type == null) {
-      expression.staticType = _dynamicType;
+      expression.staticType = DynamicTypeImpl.instance;
     } else {
       expression.staticType = type;
       if (_typeSystem.isBottom(type)) {