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