anchor.diff:      staticType = _resolver.toLegacyTypeIfOptOut(staticType);
   
       _inferenceHelper.recordStaticType(node, staticType);
  -  }
  -
  -  /// Gets the definite type of expression, which can be used in cases where
  -  /// the most precise type is desired, for example computing the least upper
  -  /// bound.
  -  ///
  -  /// See [getExpressionType] for more information. Without strong mode, this is
  -  /// equivalent to [_getStaticType].
  -  ///
  -  /// TODO(scheglov) this is duplicate
  -  DartType _getExpressionType(Expression expr, {bool read = false}) =>
  -      getExpressionType(expr, _typeSystem, _typeProvider, read: read);
  -
  -  /// Return the static type of the given [expression] that is to be used for
  -  /// type analysis.
  -  ///
  -  /// TODO(scheglov) this is duplicate
  -  DartType _getStaticType1(Expression expression, {bool read = false}) {
  -    if (expression is NullLiteral) {
  -      return _typeProvider.nullType;
  -    }
  -    DartType type = read ? getReadType(expression) : expression.staticType;
  -    return _resolveTypeParameter(type);
  -  }
  -
  -  /// Return the static type of the given [expression].
  -  ///
  -  /// TODO(scheglov) this is duplicate
  -  DartType _getStaticType2(Expression expression, {bool read = false}) {
  -    DartType type;
  -    if (read) {
  -      type = getReadType(expression);
  -    } else {
  -      if (expression is SimpleIdentifier && expression.inSetterContext()) {
  -        var element = expression.staticElement;
  -        if (element is PromotableElement) {
  -          // We're writing to the element so ignore promotions.
  -          type = element.type;
  -        } else {
  -          type = expression.staticType;
  -        }
  -      } else {
  -        type = expression.staticType;
  -      }
  -    }
  -    if (type == null) {
  -      // TODO(brianwilkerson) Determine the conditions for which the static type
  -      // is null.
  -      return DynamicTypeImpl.instance;
  -    }
  -    return type;
     }
   
     /// Return the non-nullable variant of the [type] if null safety is enabled,
  
positive.code:     Token operator = node.operator;
      TokenType operatorType = operator.type;
      Expression leftHandSide = node.leftHandSide;
      DartType staticType = _getStaticType1(leftHandSide, read: true);
  
      if (identical(staticType, NeverTypeImpl.instance)) {
        return;
      }
  
  
negative.code:   void _resolve2(AssignmentExpressionImpl node) {
      TokenType operator = node.operator.type;
      if (operator == TokenType.EQ) {
        var rightType = node.rightHandSide.staticType;
        _inferenceHelper.recordStaticType(node, rightType);
      } else if (operator == TokenType.QUESTION_QUESTION_EQ) {
        if (_isNonNullableByDefault) {
          // The static type of a compound assignment using ??= with NNBD is the
  