anchor.diff:        InstanceCreationExpression node) {
       var callee = node.staticElement;
       var typeParameters = callee.enclosingElement.typeParameters;
  +    List<DartType> typeArgumentTypes;
       List<DecoratedType> decoratedTypeArguments;
       var typeArguments = node.constructorName.type.typeArguments;
       if (typeArguments != null) {
  +      typeArgumentTypes = typeArguments.arguments.map((t) => t.type).toList();
         decoratedTypeArguments = typeArguments.arguments
             .map((t) => _variables.decoratedTypeAnnotation(source, t))
             .toList();
       } else {
         var staticType = node.staticType;
         if (staticType is InterfaceType) {
  -        decoratedTypeArguments = staticType.typeArguments
  +        typeArgumentTypes = staticType.typeArguments;
  +        decoratedTypeArguments = typeArgumentTypes
               .map((t) => DecoratedType.forImplicitType(_typeProvider, t, _graph))
               .toList();
         } else {
           // Note: this could happen if the code being migrated has errors.
  +        typeArgumentTypes = const [];
           decoratedTypeArguments = const [];
         }
       }
  
positive.code:         }
        } else {
          if (invokeType is FunctionType) {
            var argumentTypes = invokeType.typeArguments
                .map((argType) =>
                    DecoratedType.forImplicitType(_typeProvider, argType, _graph))
                .toList();
  
negative.code:     var callee = node.staticElement;
      var calleeType = _variables.decoratedElementType(callee);
      _handleInvocationArguments(
          node, node.argumentList.arguments, null, null, calleeType, null);
      return null;
    }
  
  