anchor.diff:          errorReporter: resolver.errorReporter,
         );
       }
  -    var returnType = InvocationInferrer.computeInvokeReturnType(invokeType);
  -    return _refineReturnType(resolver, node, returnType);
  +    var returnType = _refineReturnType(
  +        resolver, node, InvocationInferrer.computeInvokeReturnType(invokeType));
  +    _recordIdenticalInfo(
  +        resolver: resolver,
  +        node: node,
  +        argumentList: argumentList,
  +        identicalInfo: identicalInfo);
  +    return returnType;
     }
   
     AstNode _getErrorNode(Node node) => node;
  
positive.code:     resolver.checkUnreachableNode(argumentList);
      var flow = resolver.flowAnalysis.flow;
      var positionalParameterIndex = 0;
      List<EqualityInfo<PromotableElement, DartType>?>? identicalInfo =
          _isIdentical(node) ? [] : null;
      var arguments = argumentList.arguments;
      for (int i = 0; i < arguments.length; i++) {
        var argument = arguments[i];
  
negative.code:     required DartType? contextType,
      required List<WhyNotPromotedGetter> whyNotPromotedList,
    }) {
      List<EqualityInfo<PromotableElement, DartType>?>? identicalInfo =
          _isIdentical(node) ? [] : null;
      _visitArguments(
          resolver: resolver,
          node: node,
          argumentList: argumentList,
          rawType: rawType,
          contextType: contextType,
          whyNotPromotedList: whyNotPromotedList,
          identicalInfo: identicalInfo);
      _recordIdenticalInfo(
          resolver: resolver,
          node: node,
          argumentList: argumentList,
          identicalInfo: identicalInfo);
    }
  
    /// Computes the type context that should be used when evaluating a particular
    /// argument of the invocation.  Usually this is just the type of the
    /// corresponding parameter, but it can be different for certain primitive
    /// numeric operations.
    DartType? _computeContextForArgument(ResolverVisitor resolver, Node node,
            DartType parameterType, DartType? methodInvocationContext) =>
        parameterType;
  
    /// Determines whether [node] is an invocation of the core function
    /// `identical` (which needs special flow analysis treatment).
    bool _isIdentical(Node node) => false;
  
    /// If the invocation being processed is a call to `identical`, informs flow
    /// analysis about it, so that it can do appropriate promotions.
    void _recordIdenticalInfo(
        {required ResolverVisitor resolver,
        required Node node,
        required ArgumentListImpl argumentList,
        required List<EqualityInfo<PromotableElement, DartType>?>?
            identicalInfo}) {
      var flow = resolver.flowAnalysis.flow;
      if (identicalInfo != null) {
        flow?.equalityOperation_end(argumentList.parent as Expression,
            identicalInfo[0], identicalInfo[1]);
      }
    }
  
    /// Visits [argumentList], resolving each argument.  If any arguments need to
    /// be deferred due to the `inference-update-1` feature, a list of them is
    /// returned.
    void _visitArguments(
        {required ResolverVisitor resolver,
        required Node node,
        required ArgumentListImpl argumentList,
        required FunctionType? rawType,
        required DartType? contextType,
        required List<WhyNotPromotedGetter> whyNotPromotedList,
        required List<EqualityInfo<PromotableElement, DartType>?>?
            identicalInfo}) {
      assert(whyNotPromotedList.isEmpty);
      var parameters = rawType?.parameters;
      var namedParameters = <String, ParameterElement>{};
      if (parameters != null) {
  