anchor.diff:  }
   
   class WinRTMethodReturningVectorProjection extends WinRTMethodProjection
  -    with VectorProjection {
  +    with _VectorProjection {
     WinRTMethodReturningVectorProjection(super.method, super.vtableOffset);
   
     @override
     String toString() => '''
  -      IVector<$vectorType> $camelCasedName($methodParams) {
  +      IVector<$vectorTypeArg> $camelCasedName($methodParams) {
           final retValuePtr = calloc<COMObject>();
           $parametersPreamble
           ${ffiCall()}
           $parametersPostamble
  -        return IVector.fromRawPointer(retValuePtr$vectorArgs);
  +        return IVector.fromRawPointer(retValuePtr$vectorConstructorArgs);
         }
     ''';
   }
   
   class WinRTGetPropertyReturningVectorProjection
  -    extends WinRTGetPropertyProjection with VectorProjection {
  +    extends WinRTGetPropertyProjection with _VectorProjection {
     WinRTGetPropertyReturningVectorProjection(super.method, super.vtableOffset);
   
     @override
     String toString() => '''
  -      IVector<$vectorType> get $exposedMethodName {
  +      IVector<$vectorTypeArg> get $exposedMethodName {
           final retValuePtr = calloc<COMObject>();
   
           ${ffiCall()}
   
  -        return IVector.fromRawPointer(retValuePtr$vectorArgs);
  +        return IVector.fromRawPointer(retValuePtr$vectorConstructorArgs);
         }
     ''';
   }
   
   class WinRTMethodReturningVectorViewProjection extends WinRTMethodProjection
  -    with VectorProjection {
  +    with _VectorProjection {
     WinRTMethodReturningVectorViewProjection(super.method, super.vtableOffset);
   
     @override
     String toString() => '''
  -      List<$vectorType> $camelCasedName($methodParams) {
  +      List<$vectorTypeArg> $camelCasedName($methodParams) {
           final retValuePtr = calloc<COMObject>();
           $parametersPreamble
           ${ffiCall()}
   
           try {
  -          return IVectorView<$vectorType>.fromRawPointer(retValuePtr$vectorArgs).toList();
  +          return IVectorView<$vectorTypeArg>.fromRawPointer(retValuePtr$vectorConstructorArgs).toList();
           } finally {
             $parametersPostamble
             free(retValuePtr);
  
positive.code: }
  
  class WinRTGetPropertyReturningVectorViewProjection
      extends WinRTGetPropertyProjection with VectorProjection {
    WinRTGetPropertyReturningVectorViewProjection(
        super.method, super.vtableOffset);
  
    @override
    String toString() => '''
        List<$vectorType> get $exposedMethodName {
          final retValuePtr = calloc<COMObject>();
  
          ${ffiCall()}
  
          try {
            return IVectorView<$vectorType>.fromRawPointer(retValuePtr$vectorArgs).toList();
          } finally {
            free(retValuePtr);
          }
  
negative.code:     return typeProjection.dartType;
    }
  
    /// The constructor arguments passed to the constructors of `IVector` and
    /// `IVectorView`.
    String get vectorConstructorArgs {
      final typeProjection = TypeProjection(returnType.typeIdentifier.typeArg!);
  
      // If the type argument is a WinRT Class or Interface (e.g. StorageFile),
      // the constructor of that class must be passed in the 'creator' parameter
      // so that the 'IVector' and 'IVectorView' implementations can instantiate
      // the object
      final creator = typeProjection.isWinRT &&
              (typeProjection.isClass || typeProjection.isInterface)
          ? '${lastComponent(typeProjection.typeIdentifier.name)}.fromRawPointer'
          : null;
  
      // Similar to the 'creator' parameter above, the constructor of the enum
      // class must be passed in the 'enumCreator' parameter
      final enumCreator = typeProjection.isWinRTEnum
          ? '${lastComponent(typeProjection.typeIdentifier.name)}.from'
          : null;
  
      // If the type argument is an enum or int, it's native type (e.g. Int32,
      // Uint32) must be passed in the 'intType' parameter so that the 'IVector'
      // and 'IVectorView' implementations can use the appropriate native type
      final intType = typeProjection.isWinRTEnum || vectorTypeArg == 'int'
          ? typeProjection.nativeType
          : null;
  
  