anchor.diff:        invokeType = rawType.instantiate(inferrer.downwardsInfer());
       }
   
  -    super.resolveInvocation(
  +    List<EqualityInfo<PromotableElement, DartType>?>? identicalInfo =
  +        _isIdentical(node) ? [] : null;
  +    _visitArguments(
           resolver: resolver,
           node: node,
           argumentList: argumentList,
           rawType: invokeType,
           contextType: contextType,
  -        whyNotPromotedList: whyNotPromotedList);
  +        whyNotPromotedList: whyNotPromotedList,
  +        identicalInfo: identicalInfo);
   
       if (inferrer != null) {
         // Get the parameters that correspond to the uninstantiated generic.
  
positive.code:         whyNotPromotedList.add(flow.whyNotPromoted(argument));
        }
      }
      if (identicalInfo != null) {
        flow?.equalityOperation_end(argumentList.parent as Expression,
            identicalInfo[0], identicalInfo[1]);
      }
    }
  
    /// 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;
  
    /// Computes the return type of the method or function represented by the
    /// given type that is being invoked.
  
negative.code:         errorReporter: resolver.errorReporter,
        );
      }
      var returnType = _refineReturnType(
          resolver, node, InvocationInferrer.computeInvokeReturnType(invokeType));
      _recordIdenticalInfo(
          resolver: resolver,
          node: node,
          argumentList: argumentList,
          identicalInfo: identicalInfo);
      return returnType;
    }
  
    AstNode _getErrorNode(Node node) => node;
  