anchor.diff:          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.
  
positive.code:       invokeType = rawType.instantiate(inferrer.downwardsInfer());
      }
  
      super.resolveInvocation(
          resolver: resolver,
          node: node,
          argumentList: argumentList,
          rawType: invokeType,
          contextType: contextType,
          whyNotPromotedList: whyNotPromotedList);
  
      if (inferrer != null) {
        // Get the parameters that correspond to the uninstantiated generic.
  
negative.code:     resolver.checkUnreachableNode(argumentList);
      var flow = resolver.flowAnalysis.flow;
      var positionalParameterIndex = 0;
      var arguments = argumentList.arguments;
      for (int i = 0; i < arguments.length; i++) {
        var argument = arguments[i];
  