| __`SYSLIB1052`__ | Specified configuration is not supported by source-generated P/Invokes |
| __`SYSLIB1053`__ | Specified LibraryImportAttribute arguments cannot be forwarded to DllImportAttribute |
| __`SYSLIB1054`__ | Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time |
-| __`SYSLIB1055`__ | Invalid CustomTypeMarshallerAttribute usage |
+| __`SYSLIB1055`__ | Invalid CustomMarshallerAttribute usage |
| __`SYSLIB1056`__ | Specified native type is invalid |
| __`SYSLIB1057`__ | Marshaller type does not have the required shape |
-| __`SYSLIB1058`__ | Marshaller type defines a well-known method without specifying support for the corresponding feature |
+| __`SYSLIB1058`__ | Invalid NativeMarshallingAttribute usage |
| __`SYSLIB1059`__ | Marshaller type does not support allocating constructor |
-| __`SYSLIB1060`__ | BufferSize should be set on CustomTypeMarshallerAttribute |
+| __`SYSLIB1060`__ | Specified marshaller type is invalid |
| __`SYSLIB1061`__ | Marshaller type has incompatible method signatures |
| __`SYSLIB1062`__ | Project must be updated with '<AllowUnsafeBlocks>true</AllowUnsafeBlocks>' |
| __`SYSLIB1063`__ | *_`SYSLIB1063`-`SYSLIB1069` reserved for Microsoft.Interop.LibraryImportGenerator._* |
public const string CustomMarshallerTypeMustHaveRequiredShape = Prefix + "1057";
public const string InvalidNativeMarshallingAttributeUsage = Prefix + "1058";
public const string MissingAllocatingMarshallingFallback = Prefix + "1059";
- public const string CallerAllocConstructorMustHaveBufferSize = Prefix + "1060";
+ public const string InvalidMarshallerType = Prefix + "1060";
public const string InvalidSignaturesInMarshallerShape = Prefix + "1061";
}
// The .NET Foundation licenses this file to you under the MIT license.
using System;
+using System.Collections.Generic;
using System.Collections.Immutable;
+using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.InteropServices;
+using System.Text;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
{
public const string Key = nameof(MissingMemberNames);
public const char Delimiter = ' ';
+
+ public const string MarshalModeKey = nameof(MarshalMode);
+
+ public static ImmutableDictionary<string, string> CreateDiagnosticPropertiesForMissingMembersDiagnostic(MarshalMode mode, params string[] missingMemberNames)
+ => CreateDiagnosticPropertiesForMissingMembersDiagnostic(mode, (IEnumerable<string>)missingMemberNames);
+
+ public static ImmutableDictionary<string, string> CreateDiagnosticPropertiesForMissingMembersDiagnostic(MarshalMode mode, IEnumerable<string> missingMemberNames)
+ {
+ var builder = ImmutableDictionary.CreateBuilder<string, string>();
+ builder.Add(MarshalModeKey, mode.ToString());
+ builder.Add(Key, string.Join(Delimiter.ToString(), missingMemberNames));
+ return builder.ToImmutable();
+ }
}
+ /// <inheritdoc cref="SR.MarshallerTypeMustSpecifyManagedTypeMessage" />
public static readonly DiagnosticDescriptor MarshallerTypeMustSpecifyManagedTypeRule =
new DiagnosticDescriptor(
Ids.InvalidCustomMarshallerAttributeUsage,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.MarshallerTypeMustSpecifyManagedTypeDescription)));
- public static readonly DiagnosticDescriptor TypeMustBeUnmanagedOrStrictlyBlittableRule =
+ /// <inheritdoc cref="SR.MarshallerTypeMustBeStaticClassOrStructMessage" />
+ public static readonly DiagnosticDescriptor MarshallerTypeMustBeStaticClassOrStructRule =
+ new DiagnosticDescriptor(
+ Ids.InvalidMarshallerType,
+ GetResourceString(nameof(SR.InvalidMarshallerTypeTitle)),
+ GetResourceString(nameof(SR.MarshallerTypeMustBeStaticClassOrStructMessage)),
+ Category,
+ DiagnosticSeverity.Error,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.MarshallerTypeMustBeStaticClassOrStructDescription)));
+
+ /// <inheritdoc cref="SR.TypeMustBeUnmanagedMessage" />
+ public static readonly DiagnosticDescriptor UnmanagedTypeMustBeUnmanagedRule =
new DiagnosticDescriptor(
Ids.InvalidNativeType,
GetResourceString(nameof(SR.InvalidMarshallerTypeTitle)),
- GetResourceString(nameof(SR.TypeMustBeUnmanagedOrStrictlyBlittableMessage)),
+ GetResourceString(nameof(SR.TypeMustBeUnmanagedMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.TypeMustBeUnmanagedOrStrictlyBlittableDescription)));
+ description: GetResourceString(nameof(SR.TypeMustBeUnmanagedDescription)));
+ /// <inheritdoc cref="SR.GetPinnableReferenceReturnTypeBlittableMessage" />
public static readonly DiagnosticDescriptor GetPinnableReferenceReturnTypeBlittableRule =
new DiagnosticDescriptor(
Ids.InvalidSignaturesInMarshallerShape,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.GetPinnableReferenceReturnTypeBlittableDescription)));
+ /// <inheritdoc cref="SR.TypeMustHaveExplicitCastFromVoidPointerMessage" />
public static readonly DiagnosticDescriptor TypeMustHaveExplicitCastFromVoidPointerRule =
new DiagnosticDescriptor(
Ids.InvalidNativeType,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.TypeMustHaveExplicitCastFromVoidPointerDescription)));
- public static readonly DiagnosticDescriptor ValueInRequiresOneParameterConstructorRule =
+ /// <inheritdoc cref="SR.StatelessValueInRequiresConvertToUnmanagedMessage" />
+ public static readonly DiagnosticDescriptor StatelessValueInRequiresConvertToUnmanagedRule =
new DiagnosticDescriptor(
Ids.CustomMarshallerTypeMustHaveRequiredShape,
GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
- GetResourceString(nameof(SR.ValueInRequiresOneParameterConstructorMessage)),
+ GetResourceString(nameof(SR.StatelessValueInRequiresConvertToUnmanagedMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.ValueInRequiresOneParameterConstructorDescription)));
+ description: GetResourceString(nameof(SR.StatelessValueInRequiresConvertToUnmanagedDescription)));
- public static readonly DiagnosticDescriptor LinearCollectionInRequiresTwoParameterConstructorRule =
+ /// <inheritdoc cref="SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage" />
+ public static readonly DiagnosticDescriptor StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule =
new DiagnosticDescriptor(
Ids.CustomMarshallerTypeMustHaveRequiredShape,
GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
- GetResourceString(nameof(SR.LinearCollectionInRequiresTwoParameterConstructorMessage)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.LinearCollectionInRequiresTwoParameterConstructorDescription)));
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription)));
- public static readonly DiagnosticDescriptor ValueInCallerAllocatedBufferRequiresSpanConstructorRule =
+ /// <inheritdoc cref="SR.OutRequiresToManagedMessage" />
+ public static readonly DiagnosticDescriptor OutRequiresToManagedRule =
new DiagnosticDescriptor(
Ids.CustomMarshallerTypeMustHaveRequiredShape,
GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
- GetResourceString(nameof(SR.ValueInCallerAllocatedBufferRequiresSpanConstructorMessage)),
+ GetResourceString(nameof(SR.OutRequiresToManagedMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.ValueInCallerAllocatedBufferRequiresSpanConstructorDescription)));
+ description: GetResourceString(nameof(SR.OutRequiresToManagedDescription)));
- public static readonly DiagnosticDescriptor LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorRule =
+ /// <inheritdoc cref="SR.StatelessRequiresConvertToManagedMessage" />
+ public static readonly DiagnosticDescriptor StatelessRequiresConvertToManagedRule =
new DiagnosticDescriptor(
Ids.CustomMarshallerTypeMustHaveRequiredShape,
GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
- GetResourceString(nameof(SR.LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorMessage)),
+ GetResourceString(nameof(SR.StatelessRequiresConvertToManagedMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorDescription)));
+ description: GetResourceString(nameof(SR.StatelessRequiresConvertToManagedDescription)));
- public static readonly DiagnosticDescriptor OutRequiresToManagedRule =
+ /// <inheritdoc cref="SR.LinearCollectionInRequiresCollectionMethodsMessage" />
+ public static readonly DiagnosticDescriptor LinearCollectionInRequiresCollectionMethodsRule =
new DiagnosticDescriptor(
Ids.CustomMarshallerTypeMustHaveRequiredShape,
GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
- GetResourceString(nameof(SR.OutRequiresToManagedMessage)),
+ GetResourceString(nameof(SR.LinearCollectionInRequiresCollectionMethodsMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.OutRequiresToManagedDescription)));
+ description: GetResourceString(nameof(SR.LinearCollectionInRequiresCollectionMethodsDescription)));
- public static readonly DiagnosticDescriptor LinearCollectionInRequiresCollectionMethodsRule =
+ /// <inheritdoc cref="SR.StatelessLinearCollectionInRequiresCollectionMethodsMessage" />
+ public static readonly DiagnosticDescriptor StatelessLinearCollectionInRequiresCollectionMethodsRule =
new DiagnosticDescriptor(
Ids.CustomMarshallerTypeMustHaveRequiredShape,
GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
- GetResourceString(nameof(SR.LinearCollectionInRequiresCollectionMethodsMessage)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionInRequiresCollectionMethodsMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.LinearCollectionInRequiresCollectionMethodsDescription)));
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionInRequiresCollectionMethodsDescription)));
+ /// <inheritdoc cref="SR.LinearCollectionOutRequiresCollectionMethodsMessage" />
public static readonly DiagnosticDescriptor LinearCollectionOutRequiresCollectionMethodsRule =
new DiagnosticDescriptor(
Ids.CustomMarshallerTypeMustHaveRequiredShape,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.LinearCollectionOutRequiresCollectionMethodsDescription)));
+ /// <inheritdoc cref="SR.StatelessLinearCollectionOutRequiresCollectionMethodsMessage" />
+ public static readonly DiagnosticDescriptor StatelessLinearCollectionOutRequiresCollectionMethodsRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionOutRequiresCollectionMethodsMessage)),
+ Category,
+ DiagnosticSeverity.Error,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionOutRequiresCollectionMethodsDescription)));
+
+ /// <inheritdoc cref="SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage" />
+ public static readonly DiagnosticDescriptor StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage)),
+ Category,
+ DiagnosticSeverity.Error,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription)));
+
+ /// <inheritdoc cref="SR.CallerAllocConstructorMustHaveBufferSizeMessage" />
public static readonly DiagnosticDescriptor CallerAllocConstructorMustHaveBufferSizeRule =
new DiagnosticDescriptor(
- Ids.CallerAllocConstructorMustHaveBufferSize,
- GetResourceString(nameof(SR.CallerAllocConstructorMustHaveBufferSizeTitle)),
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
GetResourceString(nameof(SR.CallerAllocConstructorMustHaveBufferSizeMessage)),
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.CallerAllocConstructorMustHaveBufferSizeDescription)));
+ /// <inheritdoc cref="SR.CallerAllocConstructorMustHaveBufferSizeMessage" />
+ public static readonly DiagnosticDescriptor StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage)),
+ Category,
+ DiagnosticSeverity.Error,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription)));
+
+ /// <inheritdoc cref="SR.MarshallerTypeMustBeClosedOrMatchArityMessage" />
public static readonly DiagnosticDescriptor MarshallerTypeMustBeClosedOrMatchArityRule =
new DiagnosticDescriptor(
Ids.InvalidCustomMarshallerAttributeUsage,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.MarshallerTypeMustBeClosedOrMatchArityDescription)));
+ /// <inheritdoc cref="SR.MarshallerTypeMustBeNonNullMessage" />
public static readonly DiagnosticDescriptor MarshallerTypeMustBeNonNullRule =
new DiagnosticDescriptor(
Ids.InvalidCustomMarshallerAttributeUsage,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.MarshallerTypeMustBeNonNullDescription)));
- public static readonly DiagnosticDescriptor ToFromUnmanagedTypesMustMatchRule =
+ /// <inheritdoc cref="SR.FirstParameterMustMatchReturnTypeMessage" />
+ public static readonly DiagnosticDescriptor FirstParameterMustMatchReturnTypeRule =
+ new DiagnosticDescriptor(
+ Ids.InvalidSignaturesInMarshallerShape,
+ GetResourceString(nameof(SR.InvalidSignaturesInMarshallerShapeTitle)),
+ GetResourceString(nameof(SR.FirstParameterMustMatchReturnTypeMessage)),
+ Category,
+ DiagnosticSeverity.Warning,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.FirstParameterMustMatchReturnTypeDescription)));
+
+ /// <inheritdoc cref="SR.ReturnTypesMustMatchMessage" />
+ public static readonly DiagnosticDescriptor ReturnTypesMustMatchRule =
+ new DiagnosticDescriptor(
+ Ids.InvalidSignaturesInMarshallerShape,
+ GetResourceString(nameof(SR.InvalidSignaturesInMarshallerShapeTitle)),
+ GetResourceString(nameof(SR.ReturnTypesMustMatchMessage)),
+ Category,
+ DiagnosticSeverity.Warning,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.ReturnTypesMustMatchDescription)));
+
+ /// <inheritdoc cref="SR.FirstParametersMustMatchMessage" />
+ public static readonly DiagnosticDescriptor FirstParametersMustMatchRule =
+ new DiagnosticDescriptor(
+ Ids.InvalidSignaturesInMarshallerShape,
+ GetResourceString(nameof(SR.InvalidSignaturesInMarshallerShapeTitle)),
+ GetResourceString(nameof(SR.FirstParametersMustMatchMessage)),
+ Category,
+ DiagnosticSeverity.Warning,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.FirstParametersMustMatchDescription)));
+
+ /// <inheritdoc cref="SR.ElementTypesOfReturnTypesMustMatchMessage" />
+ public static readonly DiagnosticDescriptor ElementTypesOfReturnTypesMustMatchRule =
new DiagnosticDescriptor(
Ids.InvalidSignaturesInMarshallerShape,
GetResourceString(nameof(SR.InvalidSignaturesInMarshallerShapeTitle)),
- GetResourceString(nameof(SR.ToFromUnmanagedTypesMustMatchMessage)),
+ GetResourceString(nameof(SR.ElementTypesOfReturnTypesMustMatchMessage)),
Category,
DiagnosticSeverity.Warning,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.ToFromUnmanagedTypesMustMatchDescription)));
+ description: GetResourceString(nameof(SR.ElementTypesOfReturnTypesMustMatchDescription)));
- public static readonly DiagnosticDescriptor LinearCollectionElementTypesMustMatchRule =
+ /// <inheritdoc cref="SR.ReturnTypeMustBeExpectedTypeMessage" />
+ public static readonly DiagnosticDescriptor ReturnTypeMustBeExpectedTypeRule =
new DiagnosticDescriptor(
Ids.InvalidSignaturesInMarshallerShape,
GetResourceString(nameof(SR.InvalidSignaturesInMarshallerShapeTitle)),
- GetResourceString(nameof(SR.LinearCollectionElementTypesMustMatchMessage)),
+ GetResourceString(nameof(SR.ReturnTypeMustBeExpectedTypeMessage)),
Category,
DiagnosticSeverity.Warning,
isEnabledByDefault: true,
- description: GetResourceString(nameof(SR.LinearCollectionElementTypesMustMatchDescription)));
+ description: GetResourceString(nameof(SR.ReturnTypeMustBeExpectedTypeDescription)));
+ /// <inheritdoc cref="SR.ManagedTypeMustBeClosedOrMatchArityMessage" />
public static readonly DiagnosticDescriptor ManagedTypeMustBeClosedOrMatchArityRule =
new DiagnosticDescriptor(
Ids.InvalidCustomMarshallerAttributeUsage,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.ManagedTypeMustBeClosedOrMatchArityDescription)));
+ /// <inheritdoc cref="SR.ManagedTypeMustBeNonNullMessage" />
public static readonly DiagnosticDescriptor ManagedTypeMustBeNonNullRule =
new DiagnosticDescriptor(
Ids.InvalidCustomMarshallerAttributeUsage,
isEnabledByDefault: true,
description: GetResourceString(nameof(SR.ManagedTypeMustBeNonNullDescription)));
+ // We are intentionally using the same diagnostic IDs as the parent type.
+ // These diagnostics are the same diagnostics, but with a different severity,
+ // as the Default marshaller shape can have support for the managed-to-unmanaged shape
+ // the unmanaged-to-managed shape, or both.
+#pragma warning disable RS1019
+ public static class DefaultMarshalModeDiagnostics
+ {
+ /// <inheritdoc cref="CustomMarshallerAttributeAnalyzer.StatelessValueInRequiresConvertToUnmanagedRule" />
+ private static readonly DiagnosticDescriptor StatelessValueInRequiresConvertToUnmanagedRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessValueInRequiresConvertToUnmanagedMessage)),
+ Category,
+ DiagnosticSeverity.Info,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessValueInRequiresConvertToUnmanagedDescription)));
+
+ /// <inheritdoc cref="CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule" />
+ private static readonly DiagnosticDescriptor StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage)),
+ Category,
+ DiagnosticSeverity.Info,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription)));
+
+ /// <inheritdoc cref="CustomMarshallerAttributeAnalyzer.StatelessRequiresConvertToManagedRule" />
+ private static readonly DiagnosticDescriptor StatelessRequiresConvertToManagedRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessRequiresConvertToManagedMessage)),
+ Category,
+ DiagnosticSeverity.Info,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessRequiresConvertToManagedDescription)));
+
+ /// <inheritdoc cref="CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionInRequiresCollectionMethodsRule" />
+ private static readonly DiagnosticDescriptor StatelessLinearCollectionInRequiresCollectionMethodsRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionInRequiresCollectionMethodsMessage)),
+ Category,
+ DiagnosticSeverity.Info,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionInRequiresCollectionMethodsDescription)));
+
+ /// <inheritdoc cref="CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionOutRequiresCollectionMethodsMessage" />
+ private static readonly DiagnosticDescriptor StatelessLinearCollectionOutRequiresCollectionMethodsRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionOutRequiresCollectionMethodsMessage)),
+ Category,
+ DiagnosticSeverity.Info,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionOutRequiresCollectionMethodsDescription)));
+
+ /// <inheritdoc cref="CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage" />
+ private static readonly DiagnosticDescriptor StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule =
+ new DiagnosticDescriptor(
+ Ids.CustomMarshallerTypeMustHaveRequiredShape,
+ GetResourceString(nameof(SR.CustomMarshallerTypeMustHaveRequiredShapeTitle)),
+ GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage)),
+ Category,
+ DiagnosticSeverity.Info,
+ isEnabledByDefault: true,
+ description: GetResourceString(nameof(SR.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription)));
+
+ internal static DiagnosticDescriptor GetDefaultMarshalModeDiagnostic(DiagnosticDescriptor errorDescriptor)
+ {
+ if (ReferenceEquals(errorDescriptor, CustomMarshallerAttributeAnalyzer.StatelessValueInRequiresConvertToUnmanagedRule))
+ {
+ return StatelessValueInRequiresConvertToUnmanagedRule;
+ }
+ if (ReferenceEquals(errorDescriptor, CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule))
+ {
+ return StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule;
+ }
+ if (ReferenceEquals(errorDescriptor, CustomMarshallerAttributeAnalyzer.StatelessRequiresConvertToManagedRule))
+ {
+ return StatelessRequiresConvertToManagedRule;
+ }
+ if (ReferenceEquals(errorDescriptor, CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionInRequiresCollectionMethodsRule))
+ {
+ return StatelessLinearCollectionInRequiresCollectionMethodsRule;
+ }
+ if (ReferenceEquals(errorDescriptor, CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionOutRequiresCollectionMethodsRule))
+ {
+ return StatelessLinearCollectionOutRequiresCollectionMethodsRule;
+ }
+ if (ReferenceEquals(errorDescriptor, CustomMarshallerAttributeAnalyzer.StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule))
+ {
+ return StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule;
+ }
+ return errorDescriptor;
+ }
+ }
+#pragma warning restore
+
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
ImmutableArray.Create(
MarshallerTypeMustSpecifyManagedTypeRule,
- TypeMustBeUnmanagedOrStrictlyBlittableRule,
+ UnmanagedTypeMustBeUnmanagedRule,
GetPinnableReferenceReturnTypeBlittableRule,
TypeMustHaveExplicitCastFromVoidPointerRule,
- ValueInRequiresOneParameterConstructorRule,
- LinearCollectionInRequiresTwoParameterConstructorRule,
+ StatelessValueInRequiresConvertToUnmanagedRule,
+ StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule,
OutRequiresToManagedRule,
+ StatelessRequiresConvertToManagedRule,
LinearCollectionInRequiresCollectionMethodsRule,
+ StatelessLinearCollectionInRequiresCollectionMethodsRule,
LinearCollectionOutRequiresCollectionMethodsRule,
+ StatelessLinearCollectionOutRequiresCollectionMethodsRule,
+ StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule,
CallerAllocConstructorMustHaveBufferSizeRule,
MarshallerTypeMustBeClosedOrMatchArityRule,
- ToFromUnmanagedTypesMustMatchRule,
- LinearCollectionElementTypesMustMatchRule,
+ FirstParameterMustMatchReturnTypeRule,
+ ReturnTypesMustMatchRule,
+ FirstParametersMustMatchRule,
+ ElementTypesOfReturnTypesMustMatchRule,
ManagedTypeMustBeClosedOrMatchArityRule,
- ManagedTypeMustBeNonNullRule);
+ ManagedTypeMustBeNonNullRule,
+ DefaultMarshalModeDiagnostics.GetDefaultMarshalModeDiagnostic(StatelessValueInRequiresConvertToUnmanagedRule),
+ DefaultMarshalModeDiagnostics.GetDefaultMarshalModeDiagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule),
+ DefaultMarshalModeDiagnostics.GetDefaultMarshalModeDiagnostic(StatelessRequiresConvertToManagedRule),
+ DefaultMarshalModeDiagnostics.GetDefaultMarshalModeDiagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule),
+ DefaultMarshalModeDiagnostics.GetDefaultMarshalModeDiagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule),
+ DefaultMarshalModeDiagnostics.GetDefaultMarshalModeDiagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule));
public override void Initialize(AnalysisContext context)
{
DiagnosticReporter managedTypeReporter = DiagnosticReporter.CreateForLocation(syntax.FindArgumentWithNameOrArity("managedType", 0).FindTypeExpressionOrNullLocation(), context.ReportDiagnostic);
INamedTypeSymbol entryType = (INamedTypeSymbol)attributedSymbol;
- INamedTypeSymbol? managedTypeInAttribute = (INamedTypeSymbol?)attr.ConstructorArguments[0].Value;
+ ITypeSymbol? managedTypeInAttribute = (ITypeSymbol?)attr.ConstructorArguments[0].Value;
if (managedTypeInAttribute is null)
{
managedTypeReporter.CreateAndReportDiagnostic(ManagedTypeMustBeNonNullRule, entryType.ToDisplayString());
+ return;
}
if (!ManualTypeMarshallingHelper.TryResolveManagedType(
entryType,
- managedTypeInAttribute,
+ ManualTypeMarshallingHelper.ReplaceGenericPlaceholderInType(managedTypeInAttribute, entryType, context.Compilation),
ManualTypeMarshallingHelper.IsLinearCollectionEntryPoint(entryType),
(entryType, managedType) => managedTypeReporter.CreateAndReportDiagnostic(ManagedTypeMustBeClosedOrMatchArityRule, managedType, entryType), out ITypeSymbol managedType))
{
if (marshallerTypeInAttribute is null)
{
marshallerTypeReporter.CreateAndReportDiagnostic(MarshallerTypeMustBeNonNullRule);
+ return;
}
if (!ManualTypeMarshallingHelper.TryResolveMarshallerType(
entryType,
AnalyzeMarshallerType(
marshallerTypeReporter,
- (INamedTypeSymbol)managedType,
+ managedType,
(MarshalMode)attr.ConstructorArguments[1].Value,
- (INamedTypeSymbol?)marshallerType,
+ (INamedTypeSymbol)marshallerType,
ManualTypeMarshallingHelper.IsLinearCollectionEntryPoint(entryType));
}
}
+ private void AnalyzeMarshallerType(DiagnosticReporter diagnosticReporter, ITypeSymbol managedType, MarshalMode mode, INamedTypeSymbol marshallerType, bool isLinearCollectionMarshaller)
+ {
+ if (marshallerType.IsReferenceType && marshallerType.IsStatic)
+ {
+ AnalyzeStatelessMarshallerType(diagnosticReporter, managedType, mode, marshallerType, isLinearCollectionMarshaller);
+ }
+ else if (marshallerType.IsValueType)
+ {
+ AnalyzeStatefulMarshallerType(diagnosticReporter, managedType, mode, marshallerType, isLinearCollectionMarshaller);
+ }
+ else
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(MarshallerTypeMustBeStaticClassOrStructRule, marshallerType.ToDisplayString());
+ }
+ }
+
+ private void AnalyzeStatelessMarshallerType(DiagnosticReporter diagnosticReporter, ITypeSymbol managedType, MarshalMode mode, INamedTypeSymbol marshallerType, bool isLinearCollectionMarshaller)
+ {
+ var (shape, methods) = StatelessMarshallerShapeHelper.GetShapeForType(marshallerType, managedType, isLinearCollectionMarshaller, _compilation);
+
+ bool reportedDiagnostics = false;
+ DiagnosticReporter trackingReporter = new DiagnosticReporter((descriptor, properties, args) =>
+ {
+ reportedDiagnostics = true;
+ diagnosticReporter.CreateAndReportDiagnostic(descriptor, properties, args);
+ });
+ trackingReporter = AdaptReporterForMarshalMode(trackingReporter, mode);
+
+ ReportDiagnosticsForMissingMembers(trackingReporter);
+
+ // If we encountered any missing-member diagnostics, then we'll stop checking for additional errors here.
+ if (reportedDiagnostics)
+ return;
+
+ ReportDiagnosticsForMismatchedMemberSignatures(trackingReporter);
+
+ void ReportDiagnosticsForMissingMembers(DiagnosticReporter diagnosticReporter)
+ {
+ // If a caller-allocated-buffer convert method exists, verify that the BufferSize property exists
+ if (shape.HasFlag(MarshallerShape.CallerAllocatedBuffer) && mode == MarshalMode.ManagedToUnmanagedIn)
+ {
+ CheckForBufferSizeMember(
+ diagnosticReporter,
+ isLinearCollectionMarshaller ? StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeRule : CallerAllocConstructorMustHaveBufferSizeRule,
+ marshallerType,
+ methods.ToUnmanagedWithBuffer!);
+ }
+
+ if (ManualTypeMarshallingHelper.ModeUsesManagedToUnmanagedShape(mode))
+ {
+ // If the marshaller mode uses the managed->unmanaged shapes,
+ // verify that we have either a full managed-to-unmanaged shape
+ // or that our scenario supports the caller-allocated buffer managed-to-unmanaged shape
+ // and that the caller-allocated-buffer shape is present.
+ if (!(shape.HasFlag(MarshallerShape.ToUnmanaged) || (mode == MarshalMode.ManagedToUnmanagedIn && shape.HasFlag(MarshallerShape.CallerAllocatedBuffer))))
+ {
+ if (isLinearCollectionMarshaller)
+ {
+ // Verify that all of the following methods are present with valid shapes:
+ // - AllocateContainerForUnmanagedElements
+ // - GetManagedValuesSource
+ // - GetUnmanagedValuesDestination
+ if (methods.ToUnmanaged is null && methods.ToUnmanagedWithBuffer is null)
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(
+ StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule,
+ MissingMemberNames.CreateDiagnosticPropertiesForMissingMembersDiagnostic(
+ mode,
+ ShapeMemberNames.LinearCollection.Stateless.AllocateContainerForUnmanagedElements),
+ marshallerType.ToDisplayString(),
+ mode,
+ managedType.ToDisplayString());
+ }
+ List<string> missingCollectionMethods = new();
+ if (methods.ManagedValuesSource is null)
+ {
+ missingCollectionMethods.Add(ShapeMemberNames.LinearCollection.Stateless.GetManagedValuesSource);
+ }
+ if (methods.UnmanagedValuesDestination is null)
+ {
+ missingCollectionMethods.Add(ShapeMemberNames.LinearCollection.Stateless.GetUnmanagedValuesDestination);
+ }
+ if (missingCollectionMethods.Count > 0)
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(
+ StatelessLinearCollectionInRequiresCollectionMethodsRule,
+ MissingMemberNames.CreateDiagnosticPropertiesForMissingMembersDiagnostic(
+ mode,
+ missingCollectionMethods),
+ marshallerType.ToDisplayString(),
+ mode,
+ managedType.ToDisplayString());
+ }
+ }
+ else
+ {
+ // Verify that all of the following methods are present with valid shapes:
+ // - ConvertToUnmanaged
+ diagnosticReporter.CreateAndReportDiagnostic(
+ StatelessValueInRequiresConvertToUnmanagedRule,
+ MissingMemberNames.CreateDiagnosticPropertiesForMissingMembersDiagnostic(mode, ShapeMemberNames.Value.Stateless.ConvertToUnmanaged),
+ marshallerType.ToDisplayString(),
+ mode,
+ managedType.ToDisplayString());
+ }
+ }
+ }
+
+ if (ManualTypeMarshallingHelper.ModeUsesUnmanagedToManagedShape(mode))
+ {
+ // If the marshaller mode uses the unmanaged->managed shapes,
+ // verify that we have a full unmanaged-to-managed shape
+ if ((shape & (MarshallerShape.ToManaged | MarshallerShape.GuaranteedUnmarshal)) == 0)
+ {
+ if (isLinearCollectionMarshaller)
+ {
+ // Verify that all of the following methods are present with valid shapes:
+ // - AllocateContainerForUnmanagedElements
+ // - GetUnmanagedValuesSource
+ // - GetManagedValuesDestination
+ if (methods.ToManaged is null && methods.ToManagedFinally is null)
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(
+ StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule,
+ MissingMemberNames.CreateDiagnosticPropertiesForMissingMembersDiagnostic(
+ mode,
+ ShapeMemberNames.LinearCollection.Stateless.AllocateContainerForUnmanagedElements),
+ marshallerType.ToDisplayString(),
+ mode,
+ managedType.ToDisplayString());
+ }
+ List<string> missingCollectionMethods = new();
+ if (methods.UnmanagedValuesSource is null)
+ {
+ missingCollectionMethods.Add(ShapeMemberNames.LinearCollection.Stateless.GetUnmanagedValuesSource);
+ }
+ if (methods.ManagedValuesDestination is null)
+ {
+ missingCollectionMethods.Add(ShapeMemberNames.LinearCollection.Stateless.GetManagedValuesDestination);
+ }
+ if (missingCollectionMethods.Count > 0)
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(
+ StatelessLinearCollectionOutRequiresCollectionMethodsRule,
+ MissingMemberNames.CreateDiagnosticPropertiesForMissingMembersDiagnostic(
+ mode,
+ missingCollectionMethods),
+ marshallerType.ToDisplayString(),
+ mode,
+ managedType.ToDisplayString());
+ }
+ }
+ else
+ {
+ // Verify that all of the following methods are present with valid shapes:
+ // - ConvertToManaged
+ diagnosticReporter.CreateAndReportDiagnostic(StatelessRequiresConvertToManagedRule,
+ MissingMemberNames.CreateDiagnosticPropertiesForMissingMembersDiagnostic(
+ mode,
+ ShapeMemberNames.Value.Stateless.ConvertToManaged),
+ marshallerType.ToDisplayString(),
+ mode,
+ managedType.ToDisplayString());
+ }
+ }
+ }
+ }
+
+ void ReportDiagnosticsForMismatchedMemberSignatures(DiagnosticReporter diagnosticReporter)
+ {
+ // Verify that the unmanaged type used by the marshaller is consistently
+ // the same in all of the methods that use the unmanaged type.
+ // Also, verify that the collection element types are consistent.
+ ITypeSymbol? unmanagedType = null;
+ if (ManualTypeMarshallingHelper.ModeUsesManagedToUnmanagedShape(mode))
+ {
+ // First verify all usages in the managed->unmanaged shape.
+ IMethodSymbol toUnmanagedMethod = methods.ToUnmanaged ?? methods.ToUnmanagedWithBuffer;
+ unmanagedType = toUnmanagedMethod.ReturnType;
+ if (!unmanagedType.IsUnmanagedType && !unmanagedType.IsStrictlyBlittable())
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(UnmanagedTypeMustBeUnmanagedRule, toUnmanagedMethod.ToDisplayString());
+ }
+
+ if (isLinearCollectionMarshaller)
+ {
+ if (!SymbolEqualityComparer.Default.Equals(methods.UnmanagedValuesDestination.Parameters[0].Type, unmanagedType))
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(FirstParameterMustMatchReturnTypeRule, methods.UnmanagedValuesDestination.ToDisplayString(), toUnmanagedMethod.ToDisplayString());
+ }
+ }
+
+ if (shape.HasFlag(MarshallerShape.ToUnmanaged | MarshallerShape.CallerAllocatedBuffer))
+ {
+ // If the marshaller has both "ConvertToUnmanaged" method variants, verify that their return types match.
+ if (!SymbolEqualityComparer.Default.Equals(methods.ToUnmanaged.ReturnType, methods.ToUnmanagedWithBuffer.ReturnType))
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(ReturnTypesMustMatchRule, methods.ToUnmanaged.ToDisplayString(), methods.ToUnmanagedWithBuffer.ToDisplayString());
+ }
+ }
+ }
+
+ if (ManualTypeMarshallingHelper.ModeUsesUnmanagedToManagedShape(mode))
+ {
+ // Verify the usages unmanaged->managed shape
+ IMethodSymbol toManagedMethod = methods.ToManaged ?? methods.ToManagedFinally;
+
+ if (unmanagedType is not null && !SymbolEqualityComparer.Default.Equals(unmanagedType, toManagedMethod.Parameters[0].Type))
+ {
+ // If both shapes are present, verify that the unmanaged types match
+ diagnosticReporter.CreateAndReportDiagnostic(FirstParameterMustMatchReturnTypeRule, toManagedMethod.ToDisplayString(), (methods.ToUnmanaged ?? methods.ToUnmanagedWithBuffer).ToDisplayString());
+ }
+
+ unmanagedType = toManagedMethod.Parameters[0].Type;
+
+ if (isLinearCollectionMarshaller)
+ {
+ if (!SymbolEqualityComparer.Default.Equals(methods.UnmanagedValuesSource.Parameters[0].Type, unmanagedType))
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(FirstParametersMustMatchRule, methods.UnmanagedValuesSource.ToDisplayString(), toManagedMethod.ToDisplayString());
+ }
+ }
+
+ if (shape.HasFlag(MarshallerShape.ToManaged | MarshallerShape.GuaranteedUnmarshal))
+ {
+ // If the marshaller has both "ConvertToUnmanaged" method variants, verify that their parameter types match.
+ if (!SymbolEqualityComparer.Default.Equals(methods.ToManaged.Parameters[1].Type, methods.ToManagedFinally.Parameters[1].Type))
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(FirstParametersMustMatchRule, methods.ToManaged.ToDisplayString(), methods.ToManagedFinally.ToDisplayString());
+ }
+ }
+ }
+
+ // Verify that the managed collection element types match.
+ // Verify that the unmanaged collection types have the expected element types.
+ if (isLinearCollectionMarshaller)
+ {
+ if (methods.ManagedValuesSource is not null && methods.ManagedValuesDestination is not null)
+ {
+ if (TryGetElementTypeFromSpanType(methods.ManagedValuesSource.ReturnType, out ITypeSymbol sourceElementType)
+ && TryGetElementTypeFromSpanType(methods.ManagedValuesDestination.ReturnType, out ITypeSymbol destinationElementType)
+ && !SymbolEqualityComparer.Default.Equals(sourceElementType, destinationElementType))
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(ElementTypesOfReturnTypesMustMatchRule, methods.ManagedValuesSource.ToDisplayString(), methods.ManagedValuesDestination.ToDisplayString());
+ }
+ }
+
+ var (typeArguments, _) = marshallerType.GetAllTypeArgumentsIncludingInContainingTypes();
+ ITypeSymbol expectedUnmanagedCollectionElementType = typeArguments[typeArguments.Length - 1];
+ VerifyUnmanagedCollectionElementType(diagnosticReporter, methods.UnmanagedValuesSource, expectedUnmanagedCollectionElementType, _readOnlySpanOfT);
+ VerifyUnmanagedCollectionElementType(diagnosticReporter, methods.UnmanagedValuesDestination, expectedUnmanagedCollectionElementType, _spanOfT);
+ }
+ }
+ }
+
+ private void VerifyUnmanagedCollectionElementType(DiagnosticReporter diagnosticReporter, IMethodSymbol? unmanagedValuesCollectionMethod, ITypeSymbol expectedElementType, INamedTypeSymbol expectedSpanType)
+ {
+ if (unmanagedValuesCollectionMethod is not null
+ && TryGetElementTypeFromSpanType(unmanagedValuesCollectionMethod.ReturnType, out ITypeSymbol sourceElementType)
+ && !SymbolEqualityComparer.Default.Equals(sourceElementType, expectedElementType))
+ {
+ diagnosticReporter.CreateAndReportDiagnostic(ReturnTypeMustBeExpectedTypeRule, unmanagedValuesCollectionMethod.ToDisplayString(), expectedSpanType.Construct(expectedElementType).ToDisplayString());
+ }
+ }
+
+ private static DiagnosticReporter AdaptReporterForMarshalMode(DiagnosticReporter trackingReporter, MarshalMode mode)
+ {
+ if (mode == MarshalMode.Default)
+ {
+ return new DiagnosticReporter((descriptor, properties, args) => trackingReporter.CreateAndReportDiagnostic(DefaultMarshalModeDiagnostics.GetDefaultMarshalModeDiagnostic(descriptor), properties, args));
+ }
+
+ return trackingReporter;
+ }
+
+ private static void CheckForBufferSizeMember(DiagnosticReporter diagnosticReporter, DiagnosticDescriptor descriptor, INamedTypeSymbol marshallerType, IMethodSymbol callerAllocatedBufferMethod)
+ {
+ if (marshallerType.GetMembers(ShapeMemberNames.BufferSize).OfType<IPropertySymbol>().FirstOrDefault(prop => prop is { ReturnsByRef: false, ReturnsByRefReadonly: false, GetMethod: not null }) is null)
+ {
+ INamedTypeSymbol allocatedBufferType = (INamedTypeSymbol)callerAllocatedBufferMethod.Parameters[1].Type;
+ diagnosticReporter.CreateAndReportDiagnostic(
+ descriptor,
+ MissingMemberNames.CreateDiagnosticPropertiesForMissingMembersDiagnostic(MarshalMode.ManagedToUnmanagedIn, ShapeMemberNames.BufferSize),
+ marshallerType.ToDisplayString(),
+ allocatedBufferType.TypeArguments[0].ToDisplayString());
+ }
+ }
+
+ private bool TryGetElementTypeFromSpanType(ITypeSymbol spanTypeMaybe, [NotNullWhen(true)] out ITypeSymbol? elementType)
+ {
+ if (SymbolEqualityComparer.Default.Equals(spanTypeMaybe.OriginalDefinition, _spanOfT) || SymbolEqualityComparer.Default.Equals(spanTypeMaybe.OriginalDefinition, _readOnlySpanOfT))
+ {
+ elementType = ((INamedTypeSymbol)spanTypeMaybe).TypeArguments[0];
+ return true;
+ }
+ elementType = null;
+ return false;
+ }
+
#pragma warning disable CA1822 // Mark members as static
- private void AnalyzeMarshallerType(DiagnosticReporter diagnosticFactory, INamedTypeSymbol? managedType, MarshalMode mode, INamedTypeSymbol? marshallerType, bool isLinearCollectionMarshaller)
+ private void AnalyzeStatefulMarshallerType(DiagnosticReporter diagnosticReporter, ITypeSymbol managedType, MarshalMode mode, INamedTypeSymbol marshallerType, bool isLinearCollectionMarshaller)
#pragma warning restore CA1822 // Mark members as static
{
- // TODO: Implement for the V2 shapes
}
}
}
public override ImmutableArray<string> FixableDiagnosticIds { get; } =
ImmutableArray.Create(
- AnalyzerDiagnostics.Ids.CustomMarshallerTypeMustHaveRequiredShape,
- AnalyzerDiagnostics.Ids.MissingAllocatingMarshallingFallback,
- AnalyzerDiagnostics.Ids.InvalidNativeMarshallingAttributeUsage);
+ AnalyzerDiagnostics.Ids.CustomMarshallerTypeMustHaveRequiredShape);
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
public static DiagnosticReporter CreateForLocation(Location location, Action<Diagnostic> reportDiagnostic) => new((descriptor, properties, args) => reportDiagnostic(location.CreateDiagnostic(descriptor, properties, args)));
public void CreateAndReportDiagnostic(DiagnosticDescriptor descriptor, params object[] messageArgs) => _diagnosticFactory(descriptor, ImmutableDictionary<string, string>.Empty, messageArgs);
+
+ public void CreateAndReportDiagnostic(DiagnosticDescriptor descriptor, ImmutableDictionary<string, string> properties, params object[] messageArgs) => _diagnosticFactory(descriptor, properties, messageArgs);
}
}
public static readonly DiagnosticDescriptor MarshallerEntryPointTypeMustHaveCustomMarshallerAttributeWithMatchingManagedTypeRule =
new DiagnosticDescriptor(
Ids.InvalidNativeMarshallingAttributeUsage,
- GetResourceString(nameof(SR.InvalidMarshallerTypeTitle)),
+ GetResourceString(nameof(SR.InvalidNativeMarshallingAttributeUsageTitle)),
GetResourceString(nameof(SR.EntryPointTypeMustHaveCustomMarshallerAttributeWithMatchingManagedTypeMessage)),
Category,
DiagnosticSeverity.Error,
public static readonly DiagnosticDescriptor MarshallerEntryPointTypeMustBeNonNullRule =
new DiagnosticDescriptor(
Ids.InvalidNativeMarshallingAttributeUsage,
- GetResourceString(nameof(SR.InvalidMarshallerTypeTitle)),
+ GetResourceString(nameof(SR.InvalidNativeMarshallingAttributeUsageTitle)),
GetResourceString(nameof(SR.EntryPointTypeMustBeNonNullMessage)),
Category,
DiagnosticSeverity.Error,
public static readonly DiagnosticDescriptor GenericEntryPointMarshallerTypeMustBeClosedOrMatchArityRule =
new DiagnosticDescriptor(
Ids.InvalidNativeMarshallingAttributeUsage,
- GetResourceString(nameof(SR.InvalidMarshallerTypeTitle)),
+ GetResourceString(nameof(SR.InvalidNativeMarshallingAttributeUsageTitle)),
GetResourceString(nameof(SR.GenericEntryPointMarshallerTypeMustBeClosedOrMatchArityMessage)),
Category,
DiagnosticSeverity.Error,
<?xml version="1.0" encoding="utf-8"?>
<root>
- <!--
- Microsoft ResX Schema
-
+ <!--
+ Microsoft ResX Schema
+
Version 2.0
-
- The primary goals of this format is to allow a simple XML format
- that is mostly human readable. The generation and parsing of the
- various data types are done through the TypeConverter classes
+
+ The primary goals of this format is to allow a simple XML format
+ that is mostly human readable. The generation and parsing of the
+ various data types are done through the TypeConverter classes
associated with the data types.
-
+
Example:
-
+
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
-
- There are any number of "resheader" rows that contain simple
+
+ There are any number of "resheader" rows that contain simple
name/value pairs.
-
- Each data row contains a name, and value. The row also contains a
- type or mimetype. Type corresponds to a .NET class that support
- text/value conversion through the TypeConverter architecture.
- Classes that don't support this are serialized and stored with the
+
+ Each data row contains a name, and value. The row also contains a
+ type or mimetype. Type corresponds to a .NET class that support
+ text/value conversion through the TypeConverter architecture.
+ Classes that don't support this are serialized and stored with the
mimetype set.
-
- The mimetype is used for serialized objects, and tells the
- ResXResourceReader how to depersist the object. This is currently not
+
+ The mimetype is used for serialized objects, and tells the
+ ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
-
- Note - application/x-microsoft.net.object.binary.base64 is the format
- that the ResXResourceWriter will generate, however the reader can
+
+ Note - application/x-microsoft.net.object.binary.base64 is the format
+ that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
-
+
mimetype: application/x-microsoft.net.object.binary.base64
- value : The object must be serialized with
+ value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
-
+
mimetype: application/x-microsoft.net.object.soap.base64
- value : The object must be serialized with
+ value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
- value : The object must be serialized into a byte array
+ value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<data name="CallerAllocConstructorMustHaveBufferSizeMessage" xml:space="preserve">
<value>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</value>
</data>
+ <data name="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription" xml:space="preserve">
+ <value>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</value>
+ </data>
+ <data name="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage" xml:space="preserve">
+ <value>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</value>
+ </data>
<data name="CannotForwardToDllImportDescription" xml:space="preserve">
<value>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</value>
</data>
<value>Source-generated P/Invokes will ignore any configuration that is not supported.</value>
</data>
<data name="ConfigurationNotSupportedMessage" xml:space="preserve">
- <value>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</value>
+ <value>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</value>
</data>
<data name="ConfigurationNotSupportedMessageMarshallingInfo" xml:space="preserve">
<value>The specified marshalling configuration is not supported by source-generated P/Invokes. {0}.</value>
</data>
<data name="ConfigurationNotSupportedMessageParameter" xml:space="preserve">
- <value>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</value>
+ <value>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</value>
</data>
<data name="ConfigurationNotSupportedMessageReturn" xml:space="preserve">
- <value>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</value>
+ <value>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</value>
</data>
<data name="ConfigurationNotSupportedMessageValue" xml:space="preserve">
- <value>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</value>
+ <value>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</value>
</data>
<data name="ConfigurationNotSupportedTitle" xml:space="preserve">
<value>Specified configuration is not supported by source-generated P/Invokes.</value>
<data name="MarshallerTypeMustBeClosedOrMatchArityMessage" xml:space="preserve">
<value>The marshaller type '{0}' pointed to by the entry-point marshaller type '{1}' must be a closed generic type or have the same arity as the managed type</value>
</data>
- <data name="TypeMustBeUnmanagedOrStrictlyBlittableDescription" xml:space="preserve">
- <value>A native type must be blittable.</value>
+ <data name="TypeMustBeUnmanagedDescription" xml:space="preserve">
+ <value>The unmanaged type for a custom marshaller must be a C# unmanaged type.</value>
</data>
- <data name="TypeMustBeUnmanagedOrStrictlyBlittableMessage" xml:space="preserve">
- <value>The type '{0}' must be unmanaged or strictly blittable</value>
+ <data name="TypeMustBeUnmanagedMessage" xml:space="preserve">
+ <value>The return type of '{0}' must be unmanaged</value>
</data>
<data name="TypeMustHaveExplicitCastFromVoidPointerDescription" xml:space="preserve">
<value>'void*' must be castable to the type so the pinned result of the static 'GetPinnableReference' method can be passed to the native context after being pinned.</value>
<data name="LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorMessage" xml:space="preserve">
<value>The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a three-parameter constructor that takes a '{1}' , a 'Span<byte>', and an 'int'</value>
</data>
- <data name="LinearCollectionInRequiresTwoParameterConstructorDescription" xml:space="preserve">
- <value>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</value>
+ <data name="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription" xml:space="preserve">
+ <value>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</value>
+ </data>
+ <data name="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage" xml:space="preserve">
+ <value>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</value>
+ </data>
+ <data name="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription" xml:space="preserve">
+ <value>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</value>
</data>
- <data name="LinearCollectionInRequiresTwoParameterConstructorMessage" xml:space="preserve">
- <value>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</value>
+ <data name="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage" xml:space="preserve">
+ <value>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</value>
</data>
<data name="ValueInCallerAllocatedBufferRequiresSpanConstructorDescription" xml:space="preserve">
<value>A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span' of an 'unmanaged' type as parameters</value>
<data name="ValueInRequiresOneParameterConstructorMessage" xml:space="preserve">
<value>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a one-parameter constructor that takes a '{1}' as a parameter</value>
</data>
+ <data name="StatelessValueInRequiresConvertToUnmanagedDescription" xml:space="preserve">
+ <value>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</value>
+ </data>
+ <data name="StatelessValueInRequiresConvertToUnmanagedMessage" xml:space="preserve">
+ <value>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</value>
+ </data>
<data name="LinearCollectionInRequiresCollectionMethodsDescription" xml:space="preserve">
- <value>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</value>
+ <value>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</value>
</data>
<data name="LinearCollectionInRequiresCollectionMethodsMessage" xml:space="preserve">
- <value>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</value>
+ <value>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</value>
+ </data>
+ <data name="StatelessLinearCollectionInRequiresCollectionMethodsDescription" xml:space="preserve">
+ <value>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</value>
+ </data>
+ <data name="StatelessLinearCollectionInRequiresCollectionMethodsMessage" xml:space="preserve">
+ <value>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</value>
</data>
<data name="OutRequiresToManagedDescription" xml:space="preserve">
<value>A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type.</value>
<data name="OutRequiresToManagedMessage" xml:space="preserve">
<value>The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type</value>
</data>
+ <data name="StatelessRequiresConvertToManagedDescription" xml:space="preserve">
+ <value>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</value>
+ </data>
+ <data name="StatelessRequiresConvertToManagedMessage" xml:space="preserve">
+ <value>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</value>
+ </data>
<data name="LinearCollectionOutRequiresCollectionMethodsDescription" xml:space="preserve">
- <value>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</value>
+ <value>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</value>
</data>
<data name="LinearCollectionOutRequiresCollectionMethodsMessage" xml:space="preserve">
- <value>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</value>
+ <value>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</value>
+ </data>
+ <data name="StatelessLinearCollectionOutRequiresCollectionMethodsDescription" xml:space="preserve">
+ <value>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</value>
+ </data>
+ <data name="StatelessLinearCollectionOutRequiresCollectionMethodsMessage" xml:space="preserve">
+ <value>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</value>
</data>
<data name="AddMissingCustomTypeMarshallerMembers" xml:space="preserve">
<value>Add missing custom type marshaller members</value>
<data name="ToUnmanagedFromManagedTypesMustMatchMessage" xml:space="preserve">
<value>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</value>
</data>
- <data name="CallerAllocConstructorMustHaveBufferSizeTitle" xml:space="preserve">
- <value>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</value>
- </data>
<data name="CustomMarshallerTypeMustHaveRequiredShapeTitle" xml:space="preserve">
<value>Marshaller type does not have the required shape</value>
</data>
<data name="InvalidCustomMarshallerAttributeUsageTitle" xml:space="preserve">
- <value>Invalid `CustomMarshallerAttribute` usage</value>
+ <value>Invalid 'CustomMarshallerAttribute' usage</value>
+ </data>
+ <data name="InvalidNativeMarshallingAttributeUsageTitle" xml:space="preserve">
+ <value>Invalid 'NativeMarshallingAttribute' usage</value>
</data>
<data name="InvalidMarshallerTypeTitle" xml:space="preserve">
<value>Specified marshaller type is invalid</value>
<data name="MarshallerTypeMustBeNonNullMessage" xml:space="preserve">
<value>The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</value>
</data>
+ <data name="MarshallerTypeMustBeStaticClassOrStructDescription" xml:space="preserve">
+ <value>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</value>
+ </data>
+ <data name="MarshallerTypeMustBeStaticClassOrStructMessage" xml:space="preserve">
+ <value>The type '{0}' must be a static class or a value type</value>
+ </data>
+ <data name="ReturnTypesMustMatchDescription" xml:space="preserve">
+ <value>The return types of the two methods must be the same type.</value>
+ </data>
+ <data name="ReturnTypesMustMatchMessage" xml:space="preserve">
+ <value>The return type of '{0}' must be the same type as the return type of '{1}'</value>
+ </data>
+ <data name="ReturnTypeMustBeExpectedTypeDescription" xml:space="preserve">
+ <value>The return type the two method must be the expected type.</value>
+ </data>
+ <data name="ReturnTypeMustBeExpectedTypeMessage" xml:space="preserve">
+ <value>The return type of '{0}' must be '{1}'</value>
+ </data>
+ <data name="FirstParameterMustMatchReturnTypeDescription" xml:space="preserve">
+ <value>The first parameter of the first method must be the same type as the return types of the second method.</value>
+ </data>
+ <data name="FirstParameterMustMatchReturnTypeMessage" xml:space="preserve">
+ <value>The first parameter of '{0}' must be the same type as the return type of '{1}'</value>
+ </data>
+ <data name="FirstParametersMustMatchDescription" xml:space="preserve">
+ <value>The first parameters of the two methods must be the same type.</value>
+ </data>
+ <data name="FirstParametersMustMatchMessage" xml:space="preserve">
+ <value>The first parameter of '{0}' and '{1}' must be the same type</value>
+ </data>
+ <data name="ElementTypesOfReturnTypesMustMatchDescription" xml:space="preserve">
+ <value>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</value>
+ </data>
+ <data name="ElementTypesOfReturnTypesMustMatchMessage" xml:space="preserve">
+ <value>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</value>
+ </data>
<data name="RequiresAllowUnsafeBlocksDescription" xml:space="preserve">
<value>LibraryImportAttribute requires unsafe code. Project must be updated with '<AllowUnsafeBlocks>true</AllowUnsafeBlocks>'.</value>
</data>
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">Vlastnost BufferSize by měla být nastavená na CustomTypeMarshallerAttribute</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">Vygenerovaný atribut DllImportAttribute nebude mít hodnotu odpovídající {0}.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">{0} nemá žádný ekvivalent v DllImportAtttribute a nepřesměruje se</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Konfiguraci {0} nepodporují zdrojem generovaná volání P/Invokes. Pokud je určená konfigurace povinná, použijte místo ní normální DllImport.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Konfiguraci {0} nepodporují zdrojem generovaná volání P/Invokes. Pokud je určená konfigurace povinná, použijte místo ní normální DllImport.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Určená konfigurace {0} pro parametr {1} není podporována voláním P/Invokes. Pokud je určená konfigurace povinná, použijte místo ní normální DllImport.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Určená konfigurace {0} pro parametr {1} není podporována voláním P/Invokes. Pokud je určená konfigurace povinná, použijte místo ní normální DllImport.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Určenou konfiguraci {0} návratové hodnoty metody {1} nepodporují zdrojem generovaná volání P/Invokes. Pokud je určená konfigurace povinná, použijte místo ní normální Dllimport.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Určenou konfiguraci {0} návratové hodnoty metody {1} nepodporují zdrojem generovaná volání P/Invokes. Pokud je určená konfigurace povinná, použijte místo ní normální Dllimport.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">Určená hodnota {0} pro {1} se nepodporuje u volání P/Invokes generovaných zdrojem. Pokud je určená hodnota povinná, použijte místo ní regulární DllImport.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Určená hodnota {0} pro {1} se nepodporuje u volání P/Invokes generovaných zdrojem. Pokud je určená hodnota povinná, použijte místo ní regulární DllImport.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">Zařazovací typ nemá požadovaný tvar</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">Zařazovací typ má nekompatibilní signatury metod</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Nativní typ druhu LinearCollection, který podporuje zařazování ve směru „In“ musí poskytovat GetManagedValuesSource, který vrací „ReadOnlySpan<>“ a metodu GetNativeValuesDestination vracející „Span<byte>“.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Nativní typ druhu LinearCollection, který podporuje zařazování ve směru „In“ musí poskytovat GetManagedValuesSource, který vrací „ReadOnlySpan<>“ a metodu GetNativeValuesDestination vracející „Span<byte>“.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">Typ {0} určuje, že podporuje zařazování ve směru „In“, ale neposkytuje GetManagedValuesSource vracející ReadOnlySpan<>, a podporuje metodu GetNativeValuesDestination vracející „Span<byte>“</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Nativní typ druhu LinearCollection musí poskytovat dvouparametrový konstruktor, který přebírá spravovaný typ jako první parametr a nativní velikost prvku jako parametr druhý.</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">Typ {0} konkrétně určuje, že podporuje zařazování „In“ pro {1}, ale neposkytuje dvouparametrový konstruktor, který přebírá {1} jako první parametr a „int“ jako parametr druhý</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Nativní typ druhu LinearCollection, který podporuje zařazování ve směru „Out“ musí poskytovat GetManagedValuesDestination, který přebírá „int“ a vrací „Span<>“ a metodu GetNativeValuesSource přebírající „int“ a vracející „ReadOnlySpan<byte>“.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Nativní typ druhu LinearCollection, který podporuje zařazování ve směru „Out“ musí poskytovat GetManagedValuesDestination, který přebírá „int“ a vrací „Span<>“ a metodu GetNativeValuesSource přebírající „int“ a vracející „ReadOnlySpan<byte>“.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">Typ {0} konkrétně určuje, že podporuje zařazování ve směru „Out“, ale neposkytuje GetManagedValuesDestination, který přebírá „int“ a vrací „Span<>“ a metodu GetNativeValuesSource přebírající „int“ a vracející „ReadOnlySpan<byte>“</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">„BufferSize“ muss auf „CustomTypeMarshallerAttribute“ festgelegt werden</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">Das generierte \"DllImportAttribute\" weist keinen Wert auf, der \"{0}\" entspricht.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">\"{0}\" weist keine Entsprechung in \"DllImportAtttribute\" auf und wird nicht weitergeleitet.</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Die Konfiguration \"{0}\" wird von quellgenerierten P/Invokes nicht unterstützt. Wenn die angegebene Konfiguration erforderlich ist, verwenden Sie stattdessen einen regulären DllImport.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Die Konfiguration \"{0}\" wird von quellgenerierten P/Invokes nicht unterstützt. Wenn die angegebene Konfiguration erforderlich ist, verwenden Sie stattdessen einen regulären DllImport.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Die angegebene Konfiguration \"{0}\" für den Parameter \"{1}\" wird von quellgenerierten P/Invokes nicht unterstützt. Wenn die angegebene Konfiguration erforderlich ist, verwenden Sie stattdessen einen regulären \"DllImport\".</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Die angegebene Konfiguration \"{0}\" für den Parameter \"{1}\" wird von quellgenerierten P/Invokes nicht unterstützt. Wenn die angegebene Konfiguration erforderlich ist, verwenden Sie stattdessen einen regulären \"DllImport\".</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Die angegebene Konfiguration \"{0}\" für den Rückgabewert der Methode \"{1}\" wird von quellgenerierten P/Invokes nicht unterstützt. Wenn die angegebene Konfiguration erforderlich ist, verwenden Sie stattdessen einen regulären DllImport.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Die angegebene Konfiguration \"{0}\" für den Rückgabewert der Methode \"{1}\" wird von quellgenerierten P/Invokes nicht unterstützt. Wenn die angegebene Konfiguration erforderlich ist, verwenden Sie stattdessen einen regulären DllImport.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">Der angegebene Wert „{0}“ für „{1}“ wird von P/Invoke nicht unterstützt, das von der Quelle generiert wurde. Wenn der angegebene Wert erforderlich ist, verwenden Sie stattdessen einen regulären „DllImport“.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Der angegebene Wert „{0}“ für „{1}“ wird von P/Invoke nicht unterstützt, das von der Quelle generiert wurde. Wenn der angegebene Wert erforderlich ist, verwenden Sie stattdessen einen regulären „DllImport“.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">Der Marshaller-Typ weist nicht die erforderliche Form auf</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">Der Marshaller-Typ weist inkompatible Methodensignaturen auf</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Ein nativer Typ vom Typ \"LinearCollection\", der Marshalling in der Richtung \"In\" unterstützt, muss eine \"GetManagedValuesSource\" bereitstellen, die ein \"ReadOnlySpan<>\" und eine GetNativeValuesDestination-Methode zurückgibt, die eine \"Span<byte>\" zurückgibt.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Ein nativer Typ vom Typ \"LinearCollection\", der Marshalling in der Richtung \"In\" unterstützt, muss eine \"GetManagedValuesSource\" bereitstellen, die ein \"ReadOnlySpan<>\" und eine GetNativeValuesDestination-Methode zurückgibt, die eine \"Span<byte>\" zurückgibt.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">Der Typ \"{0}\" gibt an, dass Marshalling in der Richtung \"In\" unterstützt wird. Er stellt jedoch keine \"GetManagedValuesSource\" bereit, die \"ReadOnlySpan<>\" und eine GetNativeValuesDestination-Methode zurückgibt, die ein \"Span<byte>\" zurückgibt.</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Ein nativer Typ vom Typ \"LinearCollection\" muss einen Konstruktor mit zwei Parametern bereitstellen, der den verwalteten Typ als ersten Parameter und die native Größe des Elements als zweiten Parameter verwendet.</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">Der Typ \"{0}\" gibt an, dass er das In-Marshalling von \"{1}\" unterstützt, stellt jedoch keinen Konstruktor mit zwei Parametern bereit, der \"{1}\" als ersten Parameter und \"int\" als zweiten Parameter akzeptiert.</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Ein nativer Typ vom Typ \"LinearCollection\", der Marshalling in der Richtung \"Out\" unterstützt, muss eine \"GetManagedValuesDestination\" bereitstellen, die einen \"int\" akzeptiert und ein \"Span<>\" und eine GetNativeValuesSource-Methode zurückgibt, die einen \"int\" akzeptiert und ein \"ReadOnlySpan<byte>\" zurückgibt.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Ein nativer Typ vom Typ \"LinearCollection\", der Marshalling in der Richtung \"Out\" unterstützt, muss eine \"GetManagedValuesDestination\" bereitstellen, die einen \"int\" akzeptiert und ein \"Span<>\" und eine GetNativeValuesSource-Methode zurückgibt, die einen \"int\" akzeptiert und ein \"ReadOnlySpan<byte>\" zurückgibt.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">Der Typ \"{0}\" gibt an, dass Marshalling in der Out-Richtung unterstützt wird. Er stellt jedoch keine \"GetManagedValuesDestination\" bereit, die ein \"int\" akzeptiert und ein \"Span<>\" und eine GetNativeValuesSource-Methode zurückgibt, die ein \"int\" und ein \"ReadOnlySpan<byte>\" akzeptiert.</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">\"BufferSize\" debe establecerse en \"CustomTypeMarshallerAttribute\"</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">El “DllImportAttribute” generado no tendrá un valor correspondiente a “{0}”.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">“{0}” no tiene equivalente en “DllImportAtttribute” y no se reenviará</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configuración de “{0}” no está admitida por P/Invokes de un generador de código fuente. Si se requiere la configuración, use un “DllImport” normal en su lugar.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configuración de “{0}” no está admitida por P/Invokes de un generador de código fuente. Si se requiere la configuración, use un “DllImport” normal en su lugar.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configuración de “{0}” especificada para el parámetro “{1}” no es compatible con P/Invokes de un generador de código fuente. Si se requiere la configuración especificada, use un “DllImport” normal en su lugar.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configuración de “{0}” especificada para el parámetro “{1}” no es compatible con P/Invokes de un generador de código fuente. Si se requiere la configuración especificada, use un “DllImport” normal en su lugar.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configuración de “{0}” especificada para el valor devuelto del método “{1}” no es compatible con P/Invokes generados por origen. Si se requiere la configuración especificada, use un “DllImport” normal en su lugar.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configuración de “{0}” especificada para el valor devuelto del método “{1}” no es compatible con P/Invokes generados por origen. Si se requiere la configuración especificada, use un “DllImport” normal en su lugar.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">El valor especificado de \"{0}\" para \"{1}\" no es compatible con P/Invokes de un generador de código fuente. Si se requiere el valor especificado, use un \"DllImport\" normal en su lugar.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">El valor especificado de \"{0}\" para \"{1}\" no es compatible con P/Invokes de un generador de código fuente. Si se requiere el valor especificado, use un \"DllImport\" normal en su lugar.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">El tipo de serializador no tiene la forma necesaria</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">El tipo de serializador tiene firmas de método incompatibles</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Un tipo nativo de variante “LinearCollection” que admita serialización en la dirección “In” debe proporcionar un “GetManagedValuesSource” que devuelva un “ReadOnlySpan<>” y un método “GetNativeValuesDestination” que devuelva un “Span<byte>”.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Un tipo nativo de variante “LinearCollection” que admita serialización en la dirección “In” debe proporcionar un “GetManagedValuesSource” que devuelva un “ReadOnlySpan<>” y un método “GetNativeValuesDestination” que devuelva un “Span<byte>”.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">El tipo “{0}” especifica que admite la serialización en la dirección “In”, pero no proporciona un “GetManagedValuesSource” que devuelva un “ReadOnlySpan<>” y un método “GetNativeValuesDestination” que devuelva un “Span<byte>”</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Un tipo nativo de variante “LinearCollection” debe proveer un constructor de dos parámetros tomando el tipo administrado como el primer parámetro y el tamaño nativo del elemento como segundo parámetro</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">El tipo “{0}” especifica que admite la serialización “In” de “{1}” pero no proporciona un constructor de dos parámetros que toma un “{1}” como primer parámetro e “int” como segundo parámetro</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Un tipo nativo de variante “LinearCollection” que admita la serialización en la dirección “Out” debe proporcionar un “GetManagedValuesDestination” que tome un “int” y devuelva un “Span<>” y un método “GetNativeValuesSource” que tome un “int” y devuelva un “ReadOnlySpan<byte>”.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Un tipo nativo de variante “LinearCollection” que admita la serialización en la dirección “Out” debe proporcionar un “GetManagedValuesDestination” que tome un “int” y devuelva un “Span<>” y un método “GetNativeValuesSource” que tome un “int” y devuelva un “ReadOnlySpan<byte>”.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">El tipo “{0}” especifica que admite la serialización en la dirección “Out”, pero no proporciona un “GetManagedValuesDestination” que tome un “int” y devuelva un “Span<>” y un método “GetNativeValuesSource” que tome un “int” y devuelva un “ReadOnlySpan<byte>”</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">« BufferSize » doit être défini sur « CustomTypeMarshallerAttribute »</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">Le « DllImportAttribute » généré n’aura pas de valeur correspondant à « {0} ».</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">« {0} » n’a pas d’équivalent dans « DllImportAtttribute » et ne sera pas transféré</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configuration de « {0} » n’est pas prise en charge par les P/Invok générés par la source. Si la configuration spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configuration de « {0} » n’est pas prise en charge par les P/Invok générés par la source. Si la configuration spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configuration de « {0} » spécifiée pour le paramètre « {1} » n’est pas prise en charge par les P/Invok générés par la source. Si la configuration spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configuration de « {0} » spécifiée pour le paramètre « {1} » n’est pas prise en charge par les P/Invok générés par la source. Si la configuration spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configuration de « {0} » spécifiée pour la valeur renvoyée de la méthode « {1} » n’est pas prise en charge par les P/Invok générés par la source. Si la configuration spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configuration de « {0} » spécifiée pour la valeur renvoyée de la méthode « {1} » n’est pas prise en charge par les P/Invok générés par la source. Si la configuration spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">La valeur de « {0} » spécifiée pour « {1} » n’est pas prise en charge par les P/Invok générés par la source. Si la valeur spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La valeur de « {0} » spécifiée pour « {1} » n’est pas prise en charge par les P/Invok générés par la source. Si la valeur spécifiée est requise, utilisez plutôt un « DllImport » normal.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">Le type Marshaller n’a pas la forme requise</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">Le type Marshaller a des signatures de méthode incompatibles</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Un type natif de type «LinearCollection» qui prend en charge le marshaling dans la direction «In» doit fournir un «GetManagedValuesSource» qui retourne un «ReadOnlySpan<>» et une méthode «GetNativeValuesDestination» qui retourne un «Span<byte>».</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Un type natif de type «LinearCollection» qui prend en charge le marshaling dans la direction «In» doit fournir un «GetManagedValuesSource» qui retourne un «ReadOnlySpan<>» et une méthode «GetNativeValuesDestination» qui retourne un «Span<byte>».</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">Le type «{0}» spécifie qui prend en charge le marshaling dans le sens «In», mais il ne fournit pas de «GetManagedValuesSource» qui retourne un «ReadOnlySpan<>» et une méthode «GetNativeValuesDestination» qui retourne un «Span<byte>»</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Un type natif de type « LinearCollection » doit fournir un constructeur à deux paramètres prenant le type managé comme premier paramètre et la taille native de l’élément comme deuxième paramètre</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">Le type « {0} » spécifie qu’il prend en charge le marshaling « In » de « {1} » mais ne fournit pas de constructeur à deux paramètres qui accepte un « {1} » comme premier paramètre et un « int » comme second paramètre</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Un type natif de type «LinearCollection» qui prend en charge le marshaling dans la direction «Out» doit fournir un «GetManagedValuesDestination» qui prend un «int» et retourne «Span<>» et une méthode «GetNativeValuesSource» qui prend un «int» et retourne un «ReadOnlySpan<byte>».</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Un type natif de type «LinearCollection» qui prend en charge le marshaling dans la direction «Out» doit fournir un «GetManagedValuesDestination» qui prend un «int» et retourne «Span<>» et une méthode «GetNativeValuesSource» qui prend un «int» et retourne un «ReadOnlySpan<byte>».</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">Le type «{0}» spécifie qu’il prend en charge le marshaling dans la direction «Out», mais il ne fournit pas de «GetManagedValuesDestination» qui accepte «int» et retourne un «Span<>» et une méthode «GetNativeValuesSource» qui accepte «int» et renvoie un «ReadOnlySpan<byte>»</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">'BufferSize' deve essere impostato su 'CustomTypeMarshallerAttribute'</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">L'elemento 'DllImportAttribute' generato non avrà un valore corrispondente a '{0}'.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">'{0}' non ha equivalenti in 'DllImportAtttribute' e non verrà inoltrato</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configurazione '{0}' non è supportata dai P/Invoke generati dall'origine. Se la configurazione specificata è obbligatoria, usare un attributo `DllImport` normale.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configurazione '{0}' non è supportata dai P/Invoke generati dall'origine. Se la configurazione specificata è obbligatoria, usare un attributo `DllImport` normale.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configurazione '{0}' specificata per il parametro '{1}' non è supportata dai P/Invoke generati dall'origine. Se la configurazione specificata è obbligatoria, usare un attributo `DllImport` normale.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configurazione '{0}' specificata per il parametro '{1}' non è supportata dai P/Invoke generati dall'origine. Se la configurazione specificata è obbligatoria, usare un attributo `DllImport` normale.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">La configurazione '{0}' specificata per il valore restituito del metodo '{1}' non è supportata dai P/Invoke generati dall'origine. Se la configurazione specificata è obbligatoria, usare un attributo `DllImport` normale.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">La configurazione '{0}' specificata per il valore restituito del metodo '{1}' non è supportata dai P/Invoke generati dall'origine. Se la configurazione specificata è obbligatoria, usare un attributo `DllImport` normale.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">Il valore specificato '{0}' per '{1}' non è supportato da P/Invoke generati dall'origine. Se il valore specificato è obbligatorio, usare un 'DllImport' normale.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Il valore specificato '{0}' per '{1}' non è supportato da P/Invoke generati dall'origine. Se il valore specificato è obbligatorio, usare un 'DllImport' normale.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">Il tipo di marshaller non ha la forma richiesta</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">Il tipo marshaller ha firme di metodo incompatibili</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Il tipo nativo di tipo 'LinearCollection' che supporta il marshalling nella direzione 'In' deve fornire un elemento 'GetManagedValuesSource' che restituisce un elemento 'ReadOnlySpan<>' e un metodo 'GetNativeValuesDestination' che restituisce un elemento 'Span<byte>'.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Il tipo nativo di tipo 'LinearCollection' che supporta il marshalling nella direzione 'In' deve fornire un elemento 'GetManagedValuesSource' che restituisce un elemento 'ReadOnlySpan<>' e un metodo 'GetNativeValuesDestination' che restituisce un elemento 'Span<byte>'.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">Il tipo '{0}' specifica che supporta il marshalling nella direzione 'In', ma non fornisce un elemento 'GetManagedValuesSource' che restituisce un elemento 'ReadOnlySpan<>' e un metodo 'GetNativeValuesDestination' che restituisce un elemento 'Span<byte>'</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Un tipo nativo di tipo 'LinearCollection' deve fornire un costruttore a due parametri che accetta il tipo gestito come primo parametro e le dimensioni native dell'elemento come secondo parametro</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">Il tipo '{0}' specifica che supporta il marshalling 'In' di '{1}' ma non fornisce un costruttore a due parametri che accetta '{1}' come primo parametro e 'int' come secondo parametro</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Un tipo nativo di tipo 'LinearCollection' che supporta il marshalling nella direzione 'Out' deve fornire un metodo 'GetManagedValuesDestination' che accetta 'int' e restituisce un elemento 'Span<>' e un metodo 'GetNativeValuesSource' che accetta 'int' e restituisce un elemento 'ReadOnlySpan<byte>'.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Un tipo nativo di tipo 'LinearCollection' che supporta il marshalling nella direzione 'Out' deve fornire un metodo 'GetManagedValuesDestination' che accetta 'int' e restituisce un elemento 'Span<>' e un metodo 'GetNativeValuesSource' che accetta 'int' e restituisce un elemento 'ReadOnlySpan<byte>'.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">Il tipo '{0}' specifica che supporta il marshalling nella direzione 'Out', ma non fornisce un metodo 'GetManagedValuesDestination' che accetta 'int' e restituisce un elemento 'Span<>' e un metodo 'GetNativeValuesSource' che accetta 'int' e restituisce un elemento 'ReadOnlySpan<byte>'</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">'CustomTypeMarshallerAttribute' に 'BufferSize' を設定する必要があります</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">生成された 'DllImportAttribute' には、'{0}' に対応する値がありません。</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">'{0}' には、'DllImportAtttribute' に相当するものがないため、転送されません</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{0}' 構成は、ソース生成済みの P/Invoke ではサポートされていません。指定された構成が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{0}' 構成は、ソース生成済みの P/Invoke ではサポートされていません。指定された構成が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">パラメーター '{1}' 向けに指定された '{0}' 構成は、ソース生成済みの P/Invoke ではサポートされていません。指定された構成が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">パラメーター '{1}' 向けに指定された '{0}' 構成は、ソース生成済みの P/Invoke ではサポートされていません。指定された構成が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">メソッド '{1}' の戻り値向けに指定された '{0}' 構成は、ソース生成済みの P/Invoke ではサポートされていません。指定された構成が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">メソッド '{1}' の戻り値向けに指定された '{0}' 構成は、ソース生成済みの P/Invoke ではサポートされていません。指定された構成が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{0}' 向けに指定された値 '{1}' は、ソース生成済みの P/Invoke ではサポートされていません。指定された値が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{0}' 向けに指定された値 '{1}' は、ソース生成済みの P/Invoke ではサポートされていません。指定された値が必要な場合は、代わりに通常の 'DllImport' を使用します。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">マーシャラー型に必要な図形がありません</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">マーシャラー型に互換性のないメソッド シグネチャがあります</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">'In' 方向のマーシャリングをサポートする 'LinearCollection' のネイティブ型では、'ReadOnlySpan<>' を返す 'GetManagedValuesSource' と、'Span<byte>' を返す 'GetNativeValuesDestination' メソッドは指定されていません。</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">'In' 方向のマーシャリングをサポートする 'LinearCollection' のネイティブ型では、'ReadOnlySpan<>' を返す 'GetManagedValuesSource' と、'Span<byte>' を返す 'GetNativeValuesDestination' メソッドは指定されていません。</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">型 '{0}' は、'In' 方向のマーシャリングをサポートすることを指定されていますが、'ReadOnlySpan<>' を返す 'GetManagedValuesSource' と、'Span<byte>' を返す 'GetNativeValuesDestination' メソッドは指定されていません</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">'LinearCollection' 型のネイティブ型は、マネージド型を最初のパラメーターとして、要素のネイティブ サイズを 2 番目のパラメーターとして受け取る 2 つのパラメーター コンストラクターを指定する必要があります</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">型 '{0}' は、'{1}' の 'In' マーシャリングをサポートすることを指定していますが、'{1}' を最初のパラメーターとして受け取り、'int' を 2 番目のパラメーターとして受け取る 2 つのパラメーター コンストラクターを指定しません</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">'LinearCollection' のネイティブ型は、'Out' 方向のマーシャリングをサポートすることを指定されていますが、'int' を受け取って 'Span<>' を返す 'GetManagedValuesDestination' と、'int' を受け取って 'ReadOnlySpan<byte>' を返す 'GetNativeValuesDestination' メソッドを指定する必要があります。</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">'LinearCollection' のネイティブ型は、'Out' 方向のマーシャリングをサポートすることを指定されていますが、'int' を受け取って 'Span<>' を返す 'GetManagedValuesDestination' と、'int' を受け取って 'ReadOnlySpan<byte>' を返す 'GetNativeValuesDestination' メソッドを指定する必要があります。</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">型 '{0}' は、'Out' 方向のマーシャリングをサポートすることを指定されていますが、'int' を受け取って 'Span<>' を返す 'GetManagedValuesDestination' と、'int' を受け取って 'ReadOnlySpan<byte>' を返す 'GetNativeValuesDestination' メソッドは指定されていません</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">'BufferSize'는 'CustomTypeMarshallerAttribute'에서 설정해야 합니다.</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">생성된 'DllImportAttribute'에는 '{0}'에 해당하는 값이 없습니다.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">'{0}'에는 'DllImportAtttribute'에 해당하는 항목이 없으며 전달되지 않습니다.</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{0}' 구성은 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 구성이 필요한 경우 일반 'DllImport'를 대신 사용하세요.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{0}' 구성은 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 구성이 필요한 경우 일반 'DllImport'를 대신 사용하세요.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">매개 변수 '{1}'에 대해 지정된 '{0}' 구성이 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 구성이 필요한 경우 일반 'DllImport'를 대신 사용하세요.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">매개 변수 '{1}'에 대해 지정된 '{0}' 구성이 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 구성이 필요한 경우 일반 'DllImport'를 대신 사용하세요.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">메서드 '{1}'의 반환 값에 대해 지정된 '{0}' 구성은 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 구성이 필요한 경우 일반 'DllImport'를 대신 사용하세요.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">메서드 '{1}'의 반환 값에 대해 지정된 '{0}' 구성은 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 구성이 필요한 경우 일반 'DllImport'를 대신 사용하세요.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{0}'에 대해 지정된 값 '{1}은(는) 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 값이 필요한 경우 일반 ‘DllImport’를 대신 사용하세요.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{0}'에 대해 지정된 값 '{1}은(는) 소스 생성 P/Invoke에서 지원되지 않습니다. 지정된 값이 필요한 경우 일반 ‘DllImport’를 대신 사용하세요.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">마샬러 형식에 필요한 셰이프가 없습니다.</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">마샬러 형식에 호환되지 않는 메서드 시그니처가 있습니다.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">'In' 방향으로 마샬링을 지원하는 'LinearCollection' 종류의 네이티브 형식은 'ReadOnlySpan<>'을 반환하는 'GetManagedValuesSource'와 'Span<byte>'를 반환하는 'GetNativeValuesDestination' 메서드를 제공해야 합니다.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">'In' 방향으로 마샬링을 지원하는 'LinearCollection' 종류의 네이티브 형식은 'ReadOnlySpan<>'을 반환하는 'GetManagedValuesSource'와 'Span<byte>'를 반환하는 'GetNativeValuesDestination' 메서드를 제공해야 합니다.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">형식 '{0}'은(는) 'In' 방향으로 마샬링을 지원하도록 지정하지만 'ReadOnlySpan<>'을 반환하는 'GetManagedValuesSource'와 'Span<byte>를 반환하는 'GetNativeValuesDestination' 메서드를 제공하지 않습니다.</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">'LinearCollection' 종류의 네이티브 형식은 관리되는 형식을 첫 번째 매개 변수로 사용하고 요소의 네이티브 크기를 두 번째 매개 변수로 사용하는 두 개의 매개 변수 생성자를 제공해야 합니다.</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">형식 '{0}'은(는) '{1}'의 'In' 마샬링을 지원하도록 지정하지만 '{1}'을 첫 번째 매개 변수로 사용하고 'int'를 두 번째 매개 변수로 사용하는 두 개의 매개 변수 생성자를 제공하지 않습니다.</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">'Out' 방향으로 마샬링을 지원하는 'LinearCollection' 종류의 네이티브 형식은 'int'를 사용하고 'Span<>'을 반환하는 'GetManagedValuesDestination'과 'int'를 사용하고 'ReadOnlySpan<byte>'를 반환하는 'GetNativeValuesSource' 메서드를 제공해야 합니다.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">'Out' 방향으로 마샬링을 지원하는 'LinearCollection' 종류의 네이티브 형식은 'int'를 사용하고 'Span<>'을 반환하는 'GetManagedValuesDestination'과 'int'를 사용하고 'ReadOnlySpan<byte>'를 반환하는 'GetNativeValuesSource' 메서드를 제공해야 합니다.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">형식 '{0}'은(는) 'Out' 방향으로 마샬링을 지원하지만 'int'를 사용하고 'Span<>'을 반환하는 'GetManagedValuesDestination' 및 'int'를 사용하고 'ReadOnlySpan<byte>'를 반환하는 'GetNativeValuesSource' 메서드를 제공하지 않음을 지정합니다.</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">Właściwość „BufferSize” powinna być ustawiona na atrybut „CustomTypeMarshaellerAttribute”</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">Wygenerowany atrybut „DllImportAttribute” nie będzie miał wartości odpowiadającej elementowi „{0}”.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">Element „{0}” nie ma odpowiednika w parametrze „DllImportAtttribute” i nie zostanie przekazany</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Konfiguracja {0} nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Konfiguracja {0} nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Określona konfiguracja „{0}” dla parametru „{1}” nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Określona konfiguracja „{0}” dla parametru „{1}” nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Określona konfiguracja „{0}” dla wartości zwracanej przez metodę „{1}” nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Określona konfiguracja „{0}” dla wartości zwracanej przez metodę „{1}” nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">Określona wartość „{0}” dla parametru „{1}” nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Określona wartość „{0}” dla parametru „{1}” nie jest obsługiwana przez funkcję P/Invokes generowaną przez źródło. Jeśli określona konfiguracja jest wymagana, użyj zamiast tego zwykłego elementu „DllImport”.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">Typ marshallera nie ma wymaganego kształtu</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">Typ marshallera ma niezgodne sygnatury metody</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Typ natywny rodzaju „LinearCollection”, który obsługuje skierowanie w kierunku „In”, musi zapewniać element „GetManagedValuesSource”, który zwraca wartość „ReadOnlySpan<>” i metodę „GetNativeValuesDestination”, która zwraca wartość „Span<byte>”.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Typ natywny rodzaju „LinearCollection”, który obsługuje skierowanie w kierunku „In”, musi zapewniać element „GetManagedValuesSource”, który zwraca wartość „ReadOnlySpan<>” i metodę „GetNativeValuesDestination”, która zwraca wartość „Span<byte>”.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">Typ „{0}” określa, że obsługuje skierowanie w kierunku „In”, ale nie zapewnia elementu „GetManagedValuesSource”, który zwraca wartość „ReadOnlySpan<>” i metodę „GetNativeValuesDestination”, która zwraca wartość „Span<byte>”</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Typ natywny rodzaju „LinearCollection” musi dostarczać konstruktora z dwoma parametrami przyjmującego typ zarządzany jako pierwszy parametr i natywny rozmiar elementu jako drugi parametr</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">Typ „{0}” określa, że obsługuje skierowanie „In” z typu „{1}”, ale nie zapewnia konstruktora z dwoma parametrami, który przyjmuje wartość „{1}” jako pierwszy parametr i wartość „int” jako drugi parametr</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Typ natywny rodzaju „LinearCollection”, który obsługuje skierowanie w kierunku „Out”, musi zapewniać element „GetManagedValuesDestination”, który przyjmuje wartość „int” i zwraca wartość „Span<>” oraz metodę „GetNativeValuesSource”, która przyjmuje wartość „int” i zwraca wartość „ReadOnlySpan<byte>”.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Typ natywny rodzaju „LinearCollection”, który obsługuje skierowanie w kierunku „Out”, musi zapewniać element „GetManagedValuesDestination”, który przyjmuje wartość „int” i zwraca wartość „Span<>” oraz metodę „GetNativeValuesSource”, która przyjmuje wartość „int” i zwraca wartość „ReadOnlySpan<byte>”.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">Typ „{0}” określa, że obsługuje skierowanie w kierunku „Out”, ale nie zapewnia elementu „GetManagedValuesDestination”, który przyjmuje wartość „int” i zwraca wartość „Span<>” oraz metodę „GetNativeValuesSource”, która przyjmuje wartość „int”. i zwraca wartość „ReadOnlySpan<byte>”</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">'BufferSize' deve ser definido em 'CustomTypeMarshallerAttribute'</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">O 'DllImportAttribute' gerado não terá um valor correspondente a '{0}'.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">'{0}' não tem equivalente em 'DllImportAtttribute' e não será encaminhado</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">A configuração '{0}' não é suportada por P/Invokes gerados pela origem. Se a configuração especificada for necessária, use um 'DllImport' regular.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">A configuração '{0}' não é suportada por P/Invokes gerados pela origem. Se a configuração especificada for necessária, use um 'DllImport' regular.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">A configuração '{0}' especificada para o parâmetro '{1}' não é suportada por P/Invokes gerados pela origem. Se a configuração especificada for necessária, use um 'DllImport' regular.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">A configuração '{0}' especificada para o parâmetro '{1}' não é suportada por P/Invokes gerados pela origem. Se a configuração especificada for necessária, use um 'DllImport' regular.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">A configuração '{0}' especificada para o valor retornado do método '{1}' não é suportada por P/Invokes gerados pela origem. Se a configuração especificada for necessária, use um 'DllImport' regular.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">A configuração '{0}' especificada para o valor retornado do método '{1}' não é suportada por P/Invokes gerados pela origem. Se a configuração especificada for necessária, use um 'DllImport' regular.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">O valor '{0}' especificado para '{1}' não é suportada por P/Invokes gerados pela origem. Se o valor especificado for necessário, use um 'DllImport' regular.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">O valor '{0}' especificado para '{1}' não é suportada por P/Invokes gerados pela origem. Se o valor especificado for necessário, use um 'DllImport' regular.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">O tipo de marshaller não tem a forma necessária</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">O tipo de marshaller tem assinaturas de método incompatíveis</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Um tipo nativo do tipo 'LinearCollection' que dá suporte ao marshalling na direção 'In' deve fornecer um 'GetManagedValuesSource' que retorna um 'ReadOnlySpan<>' e um método 'GetNativeValuesDestination' que retorna um 'Span<byte>'.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Um tipo nativo do tipo 'LinearCollection' que dá suporte ao marshalling na direção 'In' deve fornecer um 'GetManagedValuesSource' que retorna um 'ReadOnlySpan<>' e um método 'GetNativeValuesDestination' que retorna um 'Span<byte>'.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">O tipo '{0}' especifica que é compatível com marshaling na direção 'In', mas não fornece um método 'GetManagedValuesSource' que retorna um método 'ReadOnlySpan<>' e um método 'GetNativeValuesDestination' que retorna um 'Span<byte>'</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Um tipo nativo do tipo 'LinearCollection' deve fornecer um construtor de dois parâmetros usando o tipo gerenciado como o primeiro parâmetro e o tamanho nativo do elemento como o segundo parâmetro</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">O tipo '{0}' especifica que dá suporte ao marshalling 'In' do '{1}', mas não fornece um construtor de dois parâmetros que usa um '{1}' como o primeiro parâmetro e um 'int' como o segundo parâmetro</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Um tipo nativo do tipo 'LinearCollection' que dá suporte ao marshalling na direção 'Out' deve fornecer um 'GetManagedValuesDestination' que usa um 'int' e retorna um método 'Span<>' e um método 'GetNativeValuesSource' que usa um 'int' e retorna um 'ReadOnlySpan<byte>'.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Um tipo nativo do tipo 'LinearCollection' que dá suporte ao marshalling na direção 'Out' deve fornecer um 'GetManagedValuesDestination' que usa um 'int' e retorna um método 'Span<>' e um método 'GetNativeValuesSource' que usa um 'int' e retorna um 'ReadOnlySpan<byte>'.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">O tipo '{0}' especifica que dá suporte a marshalling na direção 'Out', mas não fornece um método 'GetManagedValuesDestination' que recebe um 'int' e retorna um método 'Span<>' e um método 'GetNativeValuesSource' que usa um 'int' e retorna um 'ReadOnlySpan<byte>'</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">Параметр BufferSize должен быть задан для \"CustomTypeMarshallerAttribute\"</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">Созданный атрибут \"DllImportAttribute\" не будет иметь значения, соответствующего \"{0}\".</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">\"{0}\" не имеет эквивалента в \"DllImportAtttribute\" и не будет перенаправляться</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Конфигурация \"{0}\" не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод \"DllImport\".</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Конфигурация \"{0}\" не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод \"DllImport\".</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Указанная конфигурация \"{0}\" для параметра \"{1}\" не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод \"DllImport\".</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Указанная конфигурация \"{0}\" для параметра \"{1}\" не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод \"DllImport\".</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">Указанная конфигурация \"{0}\" для возвращаемого значения метода \"{1}\" не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод \"DllImport\".</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Указанная конфигурация \"{0}\" для возвращаемого значения метода \"{1}\" не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод \"DllImport\".</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">Указанное значение “{0}” для “{1}” не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод “DllImport”.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">Указанное значение “{0}” для “{1}” не поддерживается в P/Invoke с созданием источника. Если указанная конфигурация обязательна, используйте обычный метод “DllImport”.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">Тип маршалера не имеет требуемой фигуры</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">Тип маршалер имеет несовместимые сигнатуры методов</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">Собственный тип вида \"LinearCollection\", который поддерживает маршализацию в направлении \"внутрь\", должен предоставлять метод \"GetManagedValuesSource\", который возвращает \"ReadOnlySpan<>\", и метод \"GetNativeValuesDestination\", который возвращает \"Span<byte>\".</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">Собственный тип вида \"LinearCollection\", который поддерживает маршализацию в направлении \"внутрь\", должен предоставлять метод \"GetManagedValuesSource\", который возвращает \"ReadOnlySpan<>\", и метод \"GetNativeValuesDestination\", который возвращает \"Span<byte>\".</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">Тип \"{0}\" указывает, что поддерживает маршализацию в направлении \"внутрь\", но не предоставляет метод \"GetManagedValuesSource\", который возвращает \"ReadOnlySpan<>\", и метод \"GetNativeValuesDestination\", который возвращает \"Span<byte>\".</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">Собственный тип вида \"LinearCollection\" должен предоставлять конструктор с двумя параметрами: управляемый тип и собственный размер элемента</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">Тип \"{0}\" указывает, что поддерживает маршализацию \"{1}\" в направлении \"внутрь\", но не предоставляет конструктор, принимающий два параметра: \"{1}\" и \"int\"</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">Собственный тип вида \"LinearCollection\", который поддерживает маршализацию в направлении \"наружу\", должен предоставлять метод \"GetManagedValuesDestination\", который принимает значение \"int\" и возвращает \"Span<>\", и метод \"GetNativeValuesSource\", который принимает значение \"int\" и возвращает \"ReadOnlySpan<byte>\".</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">Собственный тип вида \"LinearCollection\", который поддерживает маршализацию в направлении \"наружу\", должен предоставлять метод \"GetManagedValuesDestination\", который принимает значение \"int\" и возвращает \"Span<>\", и метод \"GetNativeValuesSource\", который принимает значение \"int\" и возвращает \"ReadOnlySpan<byte>\".</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">Тип \"{0}\" указывает, что поддерживает маршализацию в направлении \"наружу\", но не предоставляет метод \"GetManagedValuesDestination\", который принимает значение \"int\" и возвращает \"Span<>\", и метод \"GetNativeValuesSource\", который принимает значение \"int\" и возвращает \"ReadOnlySpan<byte>\".</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">'CustomTypeMarshallerAttribute' üzerinde 'BufferSize' ayarlanmalıdır</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">Oluşturulan 'DllImportAttribute' üzerinde '{0}' için karşılık gelen bir değer bulunmaz.</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">'{0}' için 'DllImportAtttribute' içinde herhangi bir eşdeğer olmadığı için iletilemedi</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{0}' yapılandırması, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen yapılandırma gerekli ise, bunun yerine normal bir 'DllImport' kullanın.</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{0}' yapılandırması, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen yapılandırma gerekli ise, bunun yerine normal bir 'DllImport' kullanın.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{1}' parametresi için belirtilen '{0}' yapılandırması, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen yapılandırma gerekli ise, bunun yerine normal bir 'DllImport' kullanın.</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{1}' parametresi için belirtilen '{0}' yapılandırması, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen yapılandırma gerekli ise, bunun yerine normal bir 'DllImport' kullanın.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{1}' metodunun dönüş değeri için belirtilen '{0}' yapılandırması, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen yapılandırma gerekli ise, bunun yerine normal bir 'DllImport' kullanın.</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{1}' metodunun dönüş değeri için belirtilen '{0}' yapılandırması, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen yapılandırma gerekli ise, bunun yerine normal bir 'DllImport' kullanın.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">'{1}' için belirtilen '{0}' değeri, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen değer gerekli ise, bunun yerine normal bir `DllImport` kullanın.</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">'{1}' için belirtilen '{0}' değeri, kaynak tarafından oluşturulan P/Invokes tarafından desteklenmiyor. Belirtilen değer gerekli ise, bunun yerine normal bir `DllImport` kullanın.</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">Sıralayıcı türü gerekli şekle sahip değil</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">Sıralayıcı türü uyumsuz metot imzaları içeriyor</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">'In' yönünde sıralamayı destekleyen bir 'LinearCollection' tipi yerel tür, 'ReadOnlySpan<>' döndüren bir 'GetManagedValuesSource' ve 'Span<byte>' döndüren bir 'GetNativeValuesDestination' metodu sağlamalıdır.</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">'In' yönünde sıralamayı destekleyen bir 'LinearCollection' tipi yerel tür, 'ReadOnlySpan<>' döndüren bir 'GetManagedValuesSource' ve 'Span<byte>' döndüren bir 'GetNativeValuesDestination' metodu sağlamalıdır.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">'{0}' türü 'In' yönünde sıralamayı desteklediğini belirtiyor, ancak 'ReadOnlySpan<>' döndüren bir 'GetManagedValuesSource' ve 'Span<byte>' döndüren bir 'GetNativeValuesDestination' metodu sağlamıyor</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">'LinearCollection' tipi yerel türde, yönetilen türü birinci parametre olarak ve öğenin yerel boyutunu ise ikinci parametre olarak alan iki parametreli bir oluşturucu belirtilmelidir</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">'{0}' türü '{1}' için 'In' sıralamasını desteklediğini belirtiyor, ancak birinci parametre olarak '{1}' ve ikinci parametre olarak 'int' alan iki parametreli bir oluşturucu sağlamıyor</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">'Out' yönünde sıralamayı destekleyen 'LinearCollection' tipi yerel türün, 'int' alan ve 'Span<>' döndüren bir 'GetManagedValuesDestination' metodu ve 'int' alan ve 'ReadOnlySpan<byte>' döndüren bir 'GetNativeValuesSource' metodu sağlaması gerekir.</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">'Out' yönünde sıralamayı destekleyen 'LinearCollection' tipi yerel türün, 'int' alan ve 'Span<>' döndüren bir 'GetManagedValuesDestination' metodu ve 'int' alan ve 'ReadOnlySpan<byte>' döndüren bir 'GetNativeValuesSource' metodu sağlaması gerekir.</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">'{0}' türü 'Out' yönünde sıralamayı desteklediğini belirtiyor, ancak 'int' alan ve 'Span<>' döndüren bir 'GetManagedValuesDestination' metodu ve 'int' alan ve 'ReadOnlySpan<byte>' döndüren bir 'GetNativeValuesSource' metodu sağlamıyor</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">应在 \"CustomTypeMarshallerAttribute\" 上设置 \"BufferSize\"</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">生成的 “DllImportAttribute” 将不具有与“{0}”对应的值。</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">“{0}”在 “DllImportAtttribute” 中没有等效项，并且将不会被转发</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">源生成的 P/Invoke 不支持“{0}”配置。如果需要指定的配置，请改用常规的 “DllImport”。</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">源生成的 P/Invoke 不支持“{0}”配置。如果需要指定的配置，请改用常规的 “DllImport”。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">源生成的 P/Invoke 不支持为参数“{1}”指定的“{0}”配置。如果需要指定的配置，请改用常规的 `DllImport`。</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">源生成的 P/Invoke 不支持为参数“{1}”指定的“{0}”配置。如果需要指定的配置，请改用常规的 `DllImport`。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">源生成的 P/Invoke 不支持为方法“{1}”的返回值指定的“{0}”配置。如果需要指定的配置，请改用常规的 “DllImport”。</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">源生成的 P/Invoke 不支持为方法“{1}”的返回值指定的“{0}”配置。如果需要指定的配置，请改用常规的 “DllImport”。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">源生成的 P/Invoke 不支持为 \"{0}\" 指定的值 \"{1}\"。如果需要指定的值，请改用常规的 \"DllImport\"。</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">源生成的 P/Invoke 不支持为 \"{0}\" 指定的值 \"{1}\"。如果需要指定的值，请改用常规的 \"DllImport\"。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">封送程序类型没有必需的形状</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">封送程序类型具有不兼容的方法签名</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">支持在 “In” 方向进行封送的 “LinearCollection” 类型的本机类型必须提供返回 “ReadOnlySpan<>” 的 “GetManagedValuesSource” 和返回 “Span<byte>” 的 “GetNativeValuesDestination” 方法。</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">支持在 “In” 方向进行封送的 “LinearCollection” 类型的本机类型必须提供返回 “ReadOnlySpan<>” 的 “GetManagedValuesSource” 和返回 “Span<byte>” 的 “GetNativeValuesDestination” 方法。</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">类型“{0}”指定其支持按 “In” 方向进行封送，但不提供返回 “ReadOnlySpan<>” 的 “GetManagedValuesSource” 和返回 “Span<byte>” 的 “GetNativeValuesDestination” 方法</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">“LinearCollection”种类的本机类型必须提供一个采用托管类型作为第一个参数的双参数构造函数，并将元素的本机大小作为第二个参数</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">类型“{0}”指定它支持“{1}”的 “In” 封送，但不提供将“{1}”作为第一个参数和将 “int” 作为第二个参数的两参数构造函数</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">支持在 “Out” 方向进行封送的 “LinearCollection” 种类本机类型必须提供采用 “int” 并返回 “Span<>” 的 “GetManagedValuesDestination“，以及采用 “int” 并返回 “ReadOnlySpan<byte>” 的 “GetNativeValuesSource” 方法。</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">支持在 “Out” 方向进行封送的 “LinearCollection” 种类本机类型必须提供采用 “int” 并返回 “Span<>” 的 “GetManagedValuesDestination“，以及采用 “int” 并返回 “ReadOnlySpan<byte>” 的 “GetNativeValuesSource” 方法。</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">类型“{0}”指定它支持按 “Out” 方向进行封送，但不提供采用 “int” 并 “GetManagedValuesDestination“ 并返回 “Span<>” 的 “GetManagedValuesDestination”，以及采用 “int” 并返回 “ReadOnlySpan<byte>” 的 “GetNativeValuesSource” 方法</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
<target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has a FromManaged method that takes a caller-allocated 'Span<{1}>'</target>
<note />
</trans-unit>
- <trans-unit id="CallerAllocConstructorMustHaveBufferSizeTitle">
- <source>'BufferSize' should be set on 'CustomTypeMarshallerAttribute'</source>
- <target state="translated">應在 'CustomTypeMarshallerAttribute' 上設定 'BufferSize'</target>
- <note />
- </trans-unit>
<trans-unit id="CannotForwardToDllImportDescription">
<source>The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.</source>
<target state="translated">產生的 'DllImportAttribute' 將不會有對應至 '{0}' 的值。</target>
</trans-unit>
<trans-unit id="CannotForwardToDllImportMessage">
<source>'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</source>
- <target state="new">'{0}' has no equivalent in 'DllImportAttribute' and will not be forwarded</target>
+ <target state="needs-review-translation">'{0}'在 'DllImportAtttribute' 中没有相等項目，將不會轉寄</target>
<note />
</trans-unit>
<trans-unit id="CannotForwardToDllImportTitle">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessage">
- <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">来源產生的 P/Invokes 不支援為'{0}'設定。如果需要指定的設定，請改用一般 'DllImport'。</target>
+ <source>The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">来源產生的 P/Invokes 不支援為'{0}'設定。如果需要指定的設定，請改用一般 'DllImport'。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageMarshallingInfo">
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageParameter">
- <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">来源產生的 P/Invokes 不支援为参數 '{0}' 指定的'{1}'設定。如果需要指定的設定，請改用一般 'DllImport'。</target>
+ <source>The specified '{0}' configuration for parameter '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">来源產生的 P/Invokes 不支援为参數 '{0}' 指定的'{1}'設定。如果需要指定的設定，請改用一般 'DllImport'。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageReturn">
- <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.</source>
- <target state="translated">来源產生的 P/Invokes 不支援為方法 '{0}' 的傳回值指定的 '{1}' 設定。如果需要指定的設定，請改用一般 'DllImport'。</target>
+ <source>The specified '{0}' configuration for the return value of method '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">来源產生的 P/Invokes 不支援為方法 '{0}' 的傳回值指定的 '{1}' 設定。如果需要指定的設定，請改用一般 'DllImport'。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedMessageValue">
- <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular `DllImport` instead.</source>
- <target state="translated">來源產生的 P/Invokes 不支援為 '{1}' 指定的值 '{0}'。如果需要指定值，請改用一般 'DllImport'。</target>
+ <source>The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified value is required, use a regular 'DllImport' instead.</source>
+ <target state="needs-review-translation">來源產生的 P/Invokes 不支援為 '{1}' 指定的值 '{0}'。如果需要指定值，請改用一般 'DllImport'。</target>
<note />
</trans-unit>
<trans-unit id="ConfigurationNotSupportedTitle">
<target state="translated">封送處理器類型沒有必要的圖形</target>
<note />
</trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchDescription">
+ <source>The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</source>
+ <target state="new">The element type of the span returned by the first method must be the same type as the element type of the span returned by the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ElementTypesOfReturnTypesMustMatchMessage">
+ <source>The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</source>
+ <target state="new">The element type of the span returned by '{0}' must be the same type as the element type of the span returned by '{1}'.</target>
+ <note />
+ </trans-unit>
<trans-unit id="EntryPointTypeMustBeNonNullDescription">
<source>An entry-point type for marshalling a given type must not be 'null'.</source>
<target state="new">An entry-point type for marshalling a given type must not be 'null'.</target>
<target state="new">The entry-point marshaller type for the type '{0}' must be not 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeDescription">
+ <source>The first parameter of the first method must be the same type as the return types of the second method.</source>
+ <target state="new">The first parameter of the first method must be the same type as the return types of the second method.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParameterMustMatchReturnTypeMessage">
+ <source>The first parameter of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The first parameter of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchDescription">
+ <source>The first parameters of the two methods must be the same type.</source>
+ <target state="new">The first parameters of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="FirstParametersMustMatchMessage">
+ <source>The first parameter of '{0}' and '{1}' must be the same type</source>
+ <target state="new">The first parameter of '{0}' and '{1}' must be the same type</target>
+ <note />
+ </trans-unit>
<trans-unit id="FromUnmanagedOverloadsNotSupportedDescription">
<source>Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</source>
<target state="new">Overloading the 'FromUnmanaged' method is unuspported as some shapes are unable to distinguish between overloads.</target>
<note />
</trans-unit>
<trans-unit id="InvalidCustomMarshallerAttributeUsageTitle">
- <source>Invalid `CustomMarshallerAttribute` usage</source>
- <target state="new">Invalid `CustomMarshallerAttribute` usage</target>
+ <source>Invalid 'CustomMarshallerAttribute' usage</source>
+ <target state="new">Invalid 'CustomMarshallerAttribute' usage</target>
<note />
</trans-unit>
<trans-unit id="InvalidLibraryImportAttributeUsageTitle">
<target state="new">Specified marshaller type is invalid</target>
<note />
</trans-unit>
+ <trans-unit id="InvalidNativeMarshallingAttributeUsageTitle">
+ <source>Invalid 'NativeMarshallingAttribute' usage</source>
+ <target state="new">Invalid 'NativeMarshallingAttribute' usage</target>
+ <note />
+ </trans-unit>
<trans-unit id="InvalidSignaturesInMarshallerShapeTitle">
<source>Marshaller type has incompatible method signatures</source>
<target state="translated">封送處理器類型有不相容的方法簽章</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'In' direction must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'.</source>
- <target state="translated">支援以 'In' 方向排列的 'LinearCollection'-kind 原生類型，必須提供傳回 'ReadOnlySpan<>' 的 'GetManagedValuesSource' 和傳回 'Span<byte>' 的 'GetNativeValuesDestination' 方法。</target>
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'.</source>
+ <target state="needs-review-translation">支援以 'In' 方向排列的 'LinearCollection'-kind 原生類型，必須提供傳回 'ReadOnlySpan<>' 的 'GetManagedValuesSource' 和傳回 'Span<byte>' 的 'GetNativeValuesDestination' 方法。</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionInRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that is supports marshalling in the 'In' direction, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetNativeValuesDestination' method that returns a 'Span<byte>'</source>
- <target state="translated">類型 '{0}'指定支援以 'In' 方向排列，但未提供傳回 'ReadOnlySpan<>' 的 'GetManagedValuesSource' 和傳回 'Span<byte>' 的 'GetNativeValuesDestination' 方法</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorDescription">
- <source>A 'LinearCollection'-kind native type must provide a two-parameter constructor taking the managed type as the first parameter and the native size of the element as the second parameter</source>
- <target state="translated">'LinearCollection'-kind 原生類型必須提供以 Managed 類型作為第一個參數的雙參數建構函式，以及元素的原生大小做為第二個參數</target>
- <note />
- </trans-unit>
- <trans-unit id="LinearCollectionInRequiresTwoParameterConstructorMessage">
- <source>The type '{0}' specifies that it supports 'In' marshalling of '{1}' but does not provide a two-parameter constructor that takes a '{1}' as the first parameter and an 'int' as the second parameter</source>
- <target state="translated">類型 '{0}' 指定它支援 '{1}' 的 'In' 排列，但不提供接受'{1}'做为第一個參數的雙參數建構函式，以及提供作為第二個參數的 'int' 作為第二個參數</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that returns a 'Span<>'</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsDescription">
- <source>A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'.</source>
- <target state="translated">支援以 'Out' 方向排列的 'LinearCollection'-kind 原生類型必須提供接受 'int' 的 'GetManagedValuesDestination'，並傳回 'Span<>' 和採用 'int' 和 rreturns 'ReadOnlySpan<byte>' 的 'GetNativeValuesSource' 方法。</target>
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="needs-review-translation">支援以 'Out' 方向排列的 'LinearCollection'-kind 原生類型必須提供接受 'int' 的 'GetManagedValuesDestination'，並傳回 'Span<>' 和採用 'int' 和 rreturns 'ReadOnlySpan<byte>' 的 'GetNativeValuesSource' 方法。</target>
<note />
</trans-unit>
<trans-unit id="LinearCollectionOutRequiresCollectionMethodsMessage">
- <source>The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetNativeValuesSource' method that takes an 'int' and rreturns a 'ReadOnlySpan<byte>'</source>
- <target state="translated">類型 '{0}'指定它支援以 'Out' 方向排列，但未提供接受 'int' 的 'GetManagedValuesDestination'，並傳回 'Span<>' 和採用 'int' 和 rreturns 'ReadOnlySpan<byte>' 的 'GetNativeValuesSource' 方法</target>
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes an 'int' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes an 'int' and returns a 'ReadOnlySpan<>'</target>
<note />
</trans-unit>
<trans-unit id="ManagedTypeMustBeClosedOrMatchArityDescription">
<target state="new">The 'marshallerType' parameter in the 'System.Runtime.InteropServices.Marshalling.CustomMarshallerAttribute' cannot be 'null'</target>
<note />
</trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructDescription">
+ <source>A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</source>
+ <target state="new">A marshaller type must either be a stateless static class or a stateful value type. A non-static class is not allowed.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="MarshallerTypeMustBeStaticClassOrStructMessage">
+ <source>The type '{0}' must be a static class or a value type</source>
+ <target state="new">The type '{0}' must be a static class or a value type</target>
+ <note />
+ </trans-unit>
<trans-unit id="MarshallerTypeMustSpecifyManagedTypeDescription">
<source>A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</source>
<target state="new">A type with a 'System.Runtime.InteropServices.CustomMarshallerAttribute' must specify a non-'null' managed type</target>
<target state="new">LibraryImportAttribute requires unsafe code.</target>
<note />
</trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeDescription">
+ <source>The return type the two method must be the expected type.</source>
+ <target state="new">The return type the two method must be the expected type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypeMustBeExpectedTypeMessage">
+ <source>The return type of '{0}' must be '{1}'</source>
+ <target state="new">The return type of '{0}' must be '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchDescription">
+ <source>The return types of the two methods must be the same type.</source>
+ <target state="new">The return types of the two methods must be the same type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="ReturnTypesMustMatchMessage">
+ <source>The return type of '{0}' must be the same type as the return type of '{1}'</source>
+ <target state="new">The return type of '{0}' must be the same type as the return type of '{1}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeDescription">
+ <source>When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</source>
+ <target state="new">When the 'Managed to Unmanaged with Caller-Allocated Buffer' shape is used by providing an 'AllocateContainerForUnmanagedElements' method that takes a 'Span<T>' on the marshaller type, the type must provide a static 'BufferSize' property to provide the number of elements in the caller-allocated buffer.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeMessage">
+ <source>The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</source>
+ <target state="new">The marshaller type '{0}' must have a static read-only 'int' 'BufferSize' property to specify the size of the caller-allocated buffer because it has an 'AllocateContainerForUnmanagedElements' method that takes a caller-allocated 'Span<{1}>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from managed to unmanaged must provide a 'GetManagedValuesSource' that takes the managed value as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionInRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesSource' that takes '{2}' as a parameter and returns a 'ReadOnlySpan<>' and a 'GetUnmanagedValuesDestination' method that takes the unmanaged value as a parameter and returns a 'Span<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsDescription">
+ <source>A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</source>
+ <target state="new">A contiguous collection marshaller that supports marshalling from unmanaged to managed must provide a 'GetManagedValuesDestination' that takes the managed value and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionOutRequiresCollectionMethodsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode, but it does not provide a 'GetManagedValuesDestination' that takes '{2}' and returns a 'Span<>' and a 'GetUnmanagedValuesSource' method that takes the unmanaged value and an 'int' and returns a 'ReadOnlySpan<>'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForManagedElements' method taking the unmanaged type as the first parameter and the number of elements as an 'int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForManagedElements' method that takes the unmanaged type as the first parameter and an 'int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsDescription">
+ <source>A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</source>
+ <target state="new">A stateless contiguous collection marshaller that supports marshalling from managed to unmanaged must provide an 'AllocateContainerForUnmanagedElements' method taking the managed type as the first parameter and providing the number of elements as an 'out int' parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a two-parameter 'AllocateContainerForUnmanagedElements' method that takes a '{2}' as the first parameter and an 'out int' as the second parameter</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedDescription">
+ <source>A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from unmanaged to managed must provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns the the managed type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessRequiresConvertToManagedMessage">
+ <source>The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</source>
+ <target state="new">The type '{0}' specifies it supports the '{1}' marshal mode, but it does not provide a 'ConvertToManaged' method that takes the unmanaged type as a parameter and returns '{2}'</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedDescription">
+ <source>A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</source>
+ <target state="new">A stateless value marshaller that supports marshalling from managed to unmanaged must provide a one-parameter 'ConvertToUnmanaged' method that takes the managed value as the parameter and returns a value of the 'unmanaged' type.</target>
+ <note />
+ </trans-unit>
+ <trans-unit id="StatelessValueInRequiresConvertToUnmanagedMessage">
+ <source>The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</source>
+ <target state="new">The type '{0}' specifies that it supports the '{1}' marshal mode for '{2}' but does not provide a one-parameter 'ConvertToUnmanaged' method that takes a '{2}' as a parameter and returns a value of an 'unmanaged' type</target>
+ <note />
+ </trans-unit>
<trans-unit id="ToUnmanagedFromManagedTypesMustMatchDescription">
<source>The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</source>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same.</target>
<target state="new">The return type of 'ConvertToUnmanaged' and the parameter type of 'ConvertToManaged' must be the same</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableDescription">
- <source>A native type must be blittable.</source>
- <target state="new">A native type must be blittable.</target>
+ <trans-unit id="TypeMustBeUnmanagedDescription">
+ <source>The unmanaged type for a custom marshaller must be a C# unmanaged type.</source>
+ <target state="new">The unmanaged type for a custom marshaller must be a C# unmanaged type.</target>
<note />
</trans-unit>
- <trans-unit id="TypeMustBeUnmanagedOrStrictlyBlittableMessage">
- <source>The type '{0}' must be unmanaged or strictly blittable</source>
- <target state="new">The type '{0}' must be unmanaged or strictly blittable</target>
+ <trans-unit id="TypeMustBeUnmanagedMessage">
+ <source>The return type of '{0}' must be unmanaged</source>
+ <target state="new">The return type of '{0}' must be unmanaged</target>
<note />
</trans-unit>
<trans-unit id="TypeMustHaveExplicitCastFromVoidPointerDescription">
/// <param name="entryType">The marshaller type.</param>
/// <param name="compilation">The compilation to use to make new type symbols.</param>
/// <returns>The resolved managed type, or <paramref name="managedType"/> if the provided type did not have any placeholders.</returns>
- private static ITypeSymbol ReplaceGenericPlaceholderInType(ITypeSymbol managedType, INamedTypeSymbol entryType, Compilation compilation)
+ public static ITypeSymbol ReplaceGenericPlaceholderInType(ITypeSymbol managedType, INamedTypeSymbol entryType, Compilation compilation)
{
if (!entryType.IsGenericType)
{
return null;
}
- private static bool ModeUsesManagedToUnmanagedShape(MarshalMode mode)
+ public static bool ModeUsesManagedToUnmanagedShape(MarshalMode mode)
=> mode is MarshalMode.Default
or MarshalMode.ManagedToUnmanagedIn
or MarshalMode.UnmanagedToManagedOut
or MarshalMode.UnmanagedToManagedRef
or MarshalMode.ElementRef;
- private static bool ModeUsesUnmanagedToManagedShape(MarshalMode mode)
+ public static bool ModeUsesUnmanagedToManagedShape(MarshalMode mode)
=> mode is MarshalMode.Default
or MarshalMode.ManagedToUnmanagedOut
or MarshalMode.UnmanagedToManagedIn
using System;
using System.Collections.Generic;
+using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
{
public record MarshallerMethods
{
- public IMethodSymbol? ToUnmanaged;
- public IMethodSymbol? ToUnmanagedWithBuffer;
- public IMethodSymbol? ToManaged;
- public IMethodSymbol? ToManagedFinally;
+ // These properties will be set if the method is discovered, whether or not
+ // any other methods that are required are present.
+ // Use the related MarshallerShape bitmask to determine which features are actually supported.
+ public IMethodSymbol? ToUnmanaged { get; init; }
+ public IMethodSymbol? ToUnmanagedWithBuffer { get; init; }
+ public IMethodSymbol? ToManaged { get; init; }
+ public IMethodSymbol? ToManagedFinally { get; init; }
// Linear collection
- public IMethodSymbol? ManagedValuesSource;
- public IMethodSymbol? UnmanagedValuesDestination;
- public IMethodSymbol? ManagedValuesDestination;
- public IMethodSymbol? UnmanagedValuesSource;
+ public IMethodSymbol? ManagedValuesSource { get; init; }
+ public IMethodSymbol? UnmanagedValuesDestination { get; init; }
+ public IMethodSymbol? ManagedValuesDestination { get; init; }
+ public IMethodSymbol? UnmanagedValuesSource { get; init; }
}
public static (MarshallerShape, MarshallerMethods) GetShapeForType(ITypeSymbol marshallerType, ITypeSymbol managedType, bool isLinearCollectionMarshaller, Compilation compilation)
if (allocateUnmanagedWithBuffer is not null)
shape |= MarshallerShape.CallerAllocatedBuffer;
-
- methods = methods with
- {
- ToUnmanaged = allocateUnmanaged,
- ToUnmanagedWithBuffer = allocateUnmanagedWithBuffer,
- ManagedValuesSource = managedSource,
- UnmanagedValuesDestination = unmanagedDestination
- };
}
+ methods = methods with
+ {
+ ToUnmanaged = allocateUnmanaged,
+ ToUnmanagedWithBuffer = allocateUnmanagedWithBuffer,
+ ManagedValuesSource = managedSource,
+ UnmanagedValuesDestination = unmanagedDestination
+ };
+
// Unmanaged -> Managed
IMethodSymbol? allocateManaged = LinearCollection.AllocateContainerForManagedElements(marshallerType, managedType);
IMethodSymbol? allocateManagedGuaranteed = LinearCollection.AllocateContainerForManagedElementsFinally(marshallerType, managedType, spanOfT);
if (allocateManagedGuaranteed is not null)
shape |= MarshallerShape.GuaranteedUnmarshal;
-
- methods = methods with
- {
- ToManaged = allocateManaged,
- ToManagedFinally = allocateManagedGuaranteed,
- ManagedValuesDestination = managedDestination,
- UnmanagedValuesSource = unmanagedSource
- };
}
+
+ methods = methods with
+ {
+ ToManaged = allocateManaged,
+ ToManagedFinally = allocateManagedGuaranteed,
+ ManagedValuesDestination = managedDestination,
+ UnmanagedValuesSource = unmanagedSource
+ };
}
else
{
{
public record MarshallerMethods
{
+ // These properties will be set if the method is discovered, whether or not
+ // any other methods that are required are present.
+ // Use the related MarshallerShape bitmask to determine which features are actually supported.
public IMethodSymbol? FromManaged { get; init; }
public IMethodSymbol? FromManagedWithBuffer { get; init; }
public IMethodSymbol? ToManaged { get; init; }
public IMethodSymbol? ToUnmanaged { get; init; }
public IMethodSymbol? Free { get; init; }
public IMethodSymbol? OnInvoked { get; init; }
+ public IMethodSymbol? StatelessGetPinnableReference { get; init; }
public IMethodSymbol? StatefulGetPinnableReference { get; init; }
// Linear collection
|| SymbolEqualityComparer.Default.Equals(method, ToUnmanaged)
|| SymbolEqualityComparer.Default.Equals(method, Free)
|| SymbolEqualityComparer.Default.Equals(method, OnInvoked)
+ || SymbolEqualityComparer.Default.Equals(method, StatelessGetPinnableReference)
|| SymbolEqualityComparer.Default.Equals(method, StatefulGetPinnableReference)
|| SymbolEqualityComparer.Default.Equals(method, ManagedValuesSource)
|| SymbolEqualityComparer.Default.Equals(method, UnmanagedValuesDestination)
{
shape |= MarshallerShape.ToUnmanaged;
}
- methods = methods with
- {
- FromManaged = fromManaged,
- FromManagedWithBuffer = fromManagedWithCallerAllocatedBuffer,
- ToUnmanaged = toUnmanaged,
- ManagedValuesSource = managedSource,
- UnmanagedValuesDestination = unmanagedDestination
- };
}
}
+ methods = methods with
+ {
+ FromManaged = fromManaged,
+ FromManagedWithBuffer = fromManagedWithCallerAllocatedBuffer,
+ ToUnmanaged = toUnmanaged,
+ ManagedValuesSource = managedSource,
+ UnmanagedValuesDestination = unmanagedDestination
+ };
IMethodSymbol toManaged = GetToManagedMethod(marshallerType, managedType);
IMethodSymbol toManagedFinally = GetToManagedFinallyMethod(marshallerType, managedType);
{
shape |= MarshallerShape.ToManaged;
}
- methods = methods with
- {
- FromUnmanaged = fromUnmanaged,
- ToManaged = toManaged,
- ToManagedGuaranteed = toManagedFinally,
- ManagedValuesDestination = managedDestination,
- UnmanagedValuesSource = unmanagedSource
- };
}
+ methods = methods with
+ {
+ FromUnmanaged = fromUnmanaged,
+ ToManaged = toManaged,
+ ToManagedGuaranteed = toManagedFinally,
+ ManagedValuesDestination = managedDestination,
+ UnmanagedValuesSource = unmanagedSource
+ };
IMethodSymbol free = GetStatefulFreeMethod(marshallerType);
if (free is not null)
{
shape |= MarshallerShape.Free;
- methods = methods with { Free = free };
}
IMethodSymbol OnInvoked = GetOnInvokedMethod(marshallerType);
if (OnInvoked is not null)
{
shape |= MarshallerShape.OnInvoked;
- methods = methods with { OnInvoked = OnInvoked };
}
+ IMethodSymbol statelessGetPinnableReference = GetStatelessGetPinnableReference(marshallerType, managedType);
if (GetStatelessGetPinnableReference(marshallerType, managedType) is not null)
{
shape |= MarshallerShape.StatelessPinnableReference;
if (statefulGetPinnableReference is not null)
{
shape |= MarshallerShape.StatefulPinnableReference;
- methods = methods with { StatefulGetPinnableReference = statefulGetPinnableReference };
}
+ methods = methods with
+ {
+ Free = free,
+ OnInvoked = OnInvoked,
+ StatelessGetPinnableReference = statelessGetPinnableReference,
+ StatefulGetPinnableReference = statefulGetPinnableReference
+ };
return (shape, methods);
}
.FirstOrDefault(m => m is { IsStatic: false, Parameters.Length: 0, ReturnsVoid: false, ReturnsByRef: false, ReturnsByRefReadonly: false });
}
- private static IMethodSymbol? GetFromUnmanagedMethod(ITypeSymbol type, ITypeSymbol? unmanagedType)
+ public static ImmutableArray<IMethodSymbol> GetFromUnmanagedMethodCandidates(ITypeSymbol type)
{
- IMethodSymbol[] candidates = type.GetMembers(ShapeMemberNames.Value.Stateful.FromUnmanaged)
+ return type.GetMembers(ShapeMemberNames.Value.Stateful.FromUnmanaged)
.OfType<IMethodSymbol>()
.Where(m => m is { IsStatic: false, Parameters.Length: 1, ReturnsVoid: true })
- .ToArray();
+ .ToImmutableArray();
+ }
+
+ private static IMethodSymbol? GetFromUnmanagedMethod(ITypeSymbol type, ITypeSymbol? unmanagedType)
+ {
+ ImmutableArray<IMethodSymbol> candidates = GetFromUnmanagedMethodCandidates(type);
// If there are multiple overloads of FromUnmanaged, we'll treat it as not present.
// Otherwise we get into a weird state where bidirectional marshallers would support overloads
/// <returns>A fully constructed type based on <c><paramref name="unboundConstructedType"/>.ConstructedFrom</c> with the generic arguments from <paramref name="instantiatedTemplateType"/>.</returns>
public static INamedTypeSymbol ResolveUnboundConstructedTypeToConstructedType(this INamedTypeSymbol unboundConstructedType, INamedTypeSymbol instantiatedTemplateType, out int numOriginalTypeArgumentsSubstituted, out int extraTypeArgumentsInTemplate)
{
- var (typeArgumentsToSubstitute, nullableAnnotationsToSubstitute) = GetArgumentsToSubstitute(instantiatedTemplateType);
+ var (typeArgumentsToSubstitute, nullableAnnotationsToSubstitute) = instantiatedTemplateType.GetAllTypeArgumentsIncludingInContainingTypes();
// Build us a list of the type nesting of unboundConstructedType, with the outermost containing type on the top
// Use OriginalDefinition to get the generic definition for all containing types instead of having to unconstruct the generic at each loop iteration.
extraTypeArgumentsInTemplate = typeArgumentsToSubstitute.Length - currentArityOffset;
return currentType;
+ }
- // Get the type arguments and their nullable annotations from the instantiated generic type, including all levels of nesting.
- // Examples:
- // Foo<A> -> [A]
- // Foo.Bar<A> -> [A]
- // Foo<A?>.Bar<B> -> [A?, B]
- // Foo<A, B, C?>.Bar<D?, E> -> [A, B, C?, D?, E]
- static (ImmutableArray<ITypeSymbol>, ImmutableArray<NullableAnnotation>) GetArgumentsToSubstitute(INamedTypeSymbol instantiatedGeneric)
+ public static (ImmutableArray<ITypeSymbol> TypeArguments, ImmutableArray<NullableAnnotation> TypeArgumentNullableAnnotations) GetAllTypeArgumentsIncludingInContainingTypes(this INamedTypeSymbol genericType)
+ {
+ // Get the type arguments of the passed in type and all containing types
+ // with the outermost type on the top of the stack and the innermost type on the bottom of the stack.
+ Stack<(ImmutableArray<ITypeSymbol>, ImmutableArray<NullableAnnotation>)> genericTypesToSubstitute = new();
+ for (INamedTypeSymbol instantiatedType = genericType; instantiatedType is not null; instantiatedType = instantiatedType.ContainingType)
{
- Stack<(ImmutableArray<ITypeSymbol>, ImmutableArray<NullableAnnotation>)> genericTypesToSubstitute = new();
- for (INamedTypeSymbol instantiatedType = instantiatedGeneric; instantiatedType is not null; instantiatedType = instantiatedType.ContainingType)
- {
- genericTypesToSubstitute.Push((instantiatedType.TypeArguments, instantiatedType.TypeArgumentNullableAnnotations));
- }
- ImmutableArray<ITypeSymbol>.Builder typeArguments = ImmutableArray.CreateBuilder<ITypeSymbol>();
- ImmutableArray<NullableAnnotation>.Builder nullableAnnotations = ImmutableArray.CreateBuilder<NullableAnnotation>();
- while (genericTypesToSubstitute.Count != 0)
- {
- var (args, annotations) = genericTypesToSubstitute.Pop();
- typeArguments.AddRange(args);
- nullableAnnotations.AddRange(annotations);
- }
- return (typeArguments.ToImmutable(), nullableAnnotations.ToImmutable());
+ genericTypesToSubstitute.Push((instantiatedType.TypeArguments, instantiatedType.TypeArgumentNullableAnnotations));
+ }
+ // Turn our stack of lists of type arguments into one list,
+ // going from the first type argument of the outermost type to the last type argument of the innermost type.
+ ImmutableArray<ITypeSymbol>.Builder typeArguments = ImmutableArray.CreateBuilder<ITypeSymbol>();
+ ImmutableArray<NullableAnnotation>.Builder nullableAnnotations = ImmutableArray.CreateBuilder<NullableAnnotation>();
+ while (genericTypesToSubstitute.Count != 0)
+ {
+ var (args, annotations) = genericTypesToSubstitute.Pop();
+ typeArguments.AddRange(args);
+ nullableAnnotations.AddRange(annotations);
}
+ return (typeArguments.ToImmutable(), nullableAnnotations.ToImmutable());
}
}
}
namespace LibraryImportGenerator.UnitTests
{
[ActiveIssue("https://github.com/dotnet/runtime/issues/60650", TestRuntimes.Mono)]
- public class CustomMarshallerAttributeAnalyzerTests
+ public class CustomMarshallerAttributeAnalyzerTests_AttributeUsage
{
[Fact]
- public async Task NullMarshallerType_ReportsDiagnostic()
+ public async Task NullManagedType_ReportsDiagnostic()
{
string source = """
using System.Runtime.InteropServices.Marshalling;
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.Interop;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Xunit;
+using static Microsoft.Interop.Analyzers.CustomMarshallerAttributeAnalyzer;
+
+using VerifyCS = LibraryImportGenerator.UnitTests.Verifiers.CSharpCodeFixVerifier<
+ Microsoft.Interop.Analyzers.CustomMarshallerAttributeAnalyzer,
+ Microsoft.Interop.Analyzers.CustomMarshallerAttributeFixer>;
+
+namespace LibraryImportGenerator.UnitTests
+{
+ [ActiveIssue("https://github.com/dotnet/runtime/issues/60650", TestRuntimes.Mono)]
+ public class CustomMarshallerAttributeAnalyzerTests_StatelessLinearCollectionShapeValidation
+ {
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_Missing_AllMethods_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementIn, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_Missing_ContainerMethods_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementIn, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_Missing_GetManagedValuesSource_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static Span<byte> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementIn, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_Missing_GetUnmanagedValuesDestination_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static Span<byte> GetManagedValuesSource(ManagedType m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionInRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementIn, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_MismatchedUnmanagedType_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
+
+ public static Span<T> GetUnmanagedValuesDestination(int unmanaged, int numElements) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(FirstParameterMustMatchReturnTypeRule).WithLocation(0).WithArguments("MarshallerType<T>.GetUnmanagedValuesDestination(int, int)", "MarshallerType<T>.AllocateContainerForUnmanagedElements(ManagedType, out int)"),
+ VerifyCS.Diagnostic(FirstParameterMustMatchReturnTypeRule).WithLocation(1).WithArguments("MarshallerType<T>.GetUnmanagedValuesDestination(int, int)", "MarshallerType<T>.AllocateContainerForUnmanagedElements(ManagedType, out int)"),
+ VerifyCS.Diagnostic(FirstParameterMustMatchReturnTypeRule).WithLocation(2).WithArguments("MarshallerType<T>.GetUnmanagedValuesDestination(int, int)", "MarshallerType<T>.AllocateContainerForUnmanagedElements(ManagedType, out int)"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_DoesNotReportDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
+
+ public static Span<T> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source);
+ }
+
+
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_InvalidCollectionElementType_DoesNotReportDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
+
+ public static Span<byte> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(ReturnTypeMustBeExpectedTypeRule).WithLocation(0).WithArguments("MarshallerType<T>.GetUnmanagedValuesDestination(nint, int)", "System.Span<T>"),
+ VerifyCS.Diagnostic(ReturnTypeMustBeExpectedTypeRule).WithLocation(1).WithArguments("MarshallerType<T>.GetUnmanagedValuesDestination(nint, int)", "System.Span<T>"),
+ VerifyCS.Diagnostic(ReturnTypeMustBeExpectedTypeRule).WithLocation(2).WithArguments("MarshallerType<T>.GetUnmanagedValuesDestination(nint, int)", "System.Span<T>"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_Missing_AllMethods_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementOut, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_Missing_ContainerMethods_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static ManagedType AllocateContainerForManagedElements(nint m, int numElements) => throw null;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementOut, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_Missing_GetUnmanagedValuesSource_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static ManagedType AllocateContainerForManagedElements(nint m, int numElements) => throw null;
+
+ public static Span<byte> GetManagedValuesDestination(ManagedType m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementOut, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_Missing_GetManagedValuesDestination_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static ManagedType AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static Span<byte> GetUnmanagedValuesSource(nint unmanaged, int numElements) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(0).WithArguments("MarshallerType<T>", MarshalMode.ManagedToUnmanagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(1).WithArguments("MarshallerType<T>", MarshalMode.UnmanagedToManagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessLinearCollectionOutRequiresCollectionMethodsRule).WithLocation(2).WithArguments("MarshallerType<T>", MarshalMode.ElementOut, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_MismatchedUnmanagedType_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static ManagedType AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static ReadOnlySpan<T> GetUnmanagedValuesSource(int unmanaged, int numElements) => default;
+
+ public static Span<byte> GetManagedValuesDestination(ManagedType m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(FirstParametersMustMatchRule).WithLocation(0).WithArguments("MarshallerType<T>.GetUnmanagedValuesSource(int, int)", "MarshallerType<T>.AllocateContainerForManagedElements(nint, out int)"),
+ VerifyCS.Diagnostic(FirstParametersMustMatchRule).WithLocation(1).WithArguments("MarshallerType<T>.GetUnmanagedValuesSource(int, int)", "MarshallerType<T>.AllocateContainerForManagedElements(nint, out int)"),
+ VerifyCS.Diagnostic(FirstParametersMustMatchRule).WithLocation(2).WithArguments("MarshallerType<T>.GetUnmanagedValuesSource(int, int)", "MarshallerType<T>.AllocateContainerForManagedElements(nint, out int)"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_DoesNotReportDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static ManagedType AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static ReadOnlySpan<T> GetUnmanagedValuesSource(nint unmanaged, int numElements) => default;
+
+ public static Span<byte> GetManagedValuesDestination(ManagedType m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source);
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_InvalidCollectionElementType_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static ManagedType AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetUnmanagedValuesSource(nint unmanaged, int numElements) => default;
+
+ public static Span<byte> GetManagedValuesDestination(ManagedType m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(ReturnTypeMustBeExpectedTypeRule).WithLocation(0).WithArguments("MarshallerType<T>.GetUnmanagedValuesSource(nint, int)", "System.ReadOnlySpan<T>"),
+ VerifyCS.Diagnostic(ReturnTypeMustBeExpectedTypeRule).WithLocation(1).WithArguments("MarshallerType<T>.GetUnmanagedValuesSource(nint, int)", "System.ReadOnlySpan<T>"),
+ VerifyCS.Diagnostic(ReturnTypeMustBeExpectedTypeRule).WithLocation(2).WithArguments("MarshallerType<T>.GetUnmanagedValuesSource(nint, int)", "System.ReadOnlySpan<T>"));
+ }
+
+ [Fact]
+ public async Task CallerAllocatedBuffer_NoBufferSize_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, Span<byte> b, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
+
+ public static Span<byte> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessLinearCollectionCallerAllocConstructorMustHaveBufferSizeRule).WithLocation(0).WithArguments("MarshallerType<T>", "byte"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesBidirectionalShape_DoesNotReportDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedRef, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedRef, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementRef, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
+
+ public static Span<T> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+
+ public static ManagedType AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static ReadOnlySpan<T> GetUnmanagedValuesSource(nint unmanaged, int numElements) => default;
+
+ public static Span<int> GetManagedValuesDestination(ManagedType m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(source);
+ }
+
+ [Fact]
+ public async Task ModeThatUsesBidirectionalShape_MismatchedManagedElementTypes_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedRef, typeof({|#0:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedRef, typeof({|#1:MarshallerType<>|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementRef, typeof({|#2:MarshallerType<>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
+
+ public static Span<T> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+
+ public static ManagedType AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static ReadOnlySpan<T> GetUnmanagedValuesSource(nint unmanaged, int numElements) => default;
+
+ public static Span<byte> GetManagedValuesDestination(ManagedType m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(source,
+ VerifyCS.Diagnostic(ElementTypesOfReturnTypesMustMatchRule).WithLocation(0).WithArguments("MarshallerType<T>.GetManagedValuesSource(ManagedType)", "MarshallerType<T>.GetManagedValuesDestination(ManagedType)"),
+ VerifyCS.Diagnostic(ElementTypesOfReturnTypesMustMatchRule).WithLocation(1).WithArguments("MarshallerType<T>.GetManagedValuesSource(ManagedType)", "MarshallerType<T>.GetManagedValuesDestination(ManagedType)"),
+ VerifyCS.Diagnostic(ElementTypesOfReturnTypesMustMatchRule).WithLocation(2).WithArguments("MarshallerType<T>.GetManagedValuesSource(ManagedType)", "MarshallerType<T>.GetManagedValuesDestination(ManagedType)"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesBidirectionalShape_ArrayTarget_DoesNotReportDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ [CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder[]), MarshalMode.ManagedToUnmanagedRef, typeof({|#0:MarshallerType<,>|}))]
+ [CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder[]), MarshalMode.UnmanagedToManagedRef, typeof({|#1:MarshallerType<,>|}))]
+ [CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder[]), MarshalMode.ElementRef, typeof({|#2:MarshallerType<,>|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T, TNative>
+ {
+ public static nint AllocateContainerForUnmanagedElements(T[] m, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(T[] m) => default;
+
+ public static Span<TNative> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+
+ public static T[] AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static ReadOnlySpan<TNative> GetUnmanagedValuesSource(nint unmanaged, int numElements) => default;
+
+ public static Span<int> GetManagedValuesDestination(T[] m) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(source);
+ }
+
+ [Fact]
+ public async Task ModeThatUsesBidirectionalShape_NestedGeneric_DoesNotReportDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedRef, typeof({|#0:MarshallerType<>.Nested|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedRef, typeof({|#1:MarshallerType<>.Nested|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementRef, typeof({|#2:MarshallerType<>.Nested|}))]
+ [ContiguousCollectionMarshaller]
+ static class MarshallerType<T>
+ {
+ public static class Nested
+ {
+ public static nint AllocateContainerForUnmanagedElements(ManagedType m, out int numElements) => throw null;
+
+ public static ReadOnlySpan<int> GetManagedValuesSource(ManagedType m) => default;
+
+ public static Span<T> GetUnmanagedValuesDestination(nint unmanaged, int numElements) => default;
+
+ public static ManagedType AllocateContainerForManagedElements(nint unmanaged, out int numElements) => throw null;
+
+ public static ReadOnlySpan<T> GetUnmanagedValuesSource(nint unmanaged, int numElements) => default;
+
+ public static Span<int> GetManagedValuesDestination(ManagedType m) => default;
+ }
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(source);
+ }
+ }
+}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.Interop;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Xunit;
+using static Microsoft.Interop.Analyzers.CustomMarshallerAttributeAnalyzer;
+
+using VerifyCS = LibraryImportGenerator.UnitTests.Verifiers.CSharpCodeFixVerifier<
+ Microsoft.Interop.Analyzers.CustomMarshallerAttributeAnalyzer,
+ Microsoft.Interop.Analyzers.CustomMarshallerAttributeFixer>;
+
+namespace LibraryImportGenerator.UnitTests
+{
+ [ActiveIssue("https://github.com/dotnet/runtime/issues/60650", TestRuntimes.Mono)]
+ public class CustomMarshallerAttributeAnalyzerTests_StatelessValueShapeValidation
+ {
+ [Fact]
+ public async Task ModeThatUsesManagedToUnmanagedShape_Missing_ConvertToUnmanagedMethod_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedOut, typeof({|#1:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementIn, typeof({|#2:MarshallerType|}))]
+ static class MarshallerType
+ {
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessValueInRequiresConvertToUnmanagedRule).WithLocation(0).WithArguments("MarshallerType", MarshalMode.ManagedToUnmanagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessValueInRequiresConvertToUnmanagedRule).WithLocation(1).WithArguments("MarshallerType", MarshalMode.UnmanagedToManagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessValueInRequiresConvertToUnmanagedRule).WithLocation(2).WithArguments("MarshallerType", MarshalMode.ElementIn, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesUnmanagedToManagedShape_Missing_ConvertToManagedMethod_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedOut, typeof({|#0:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedIn, typeof({|#1:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementOut, typeof({|#2:MarshallerType|}))]
+ static class MarshallerType
+ {
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessRequiresConvertToManagedRule).WithLocation(0).WithArguments("MarshallerType", MarshalMode.ManagedToUnmanagedOut, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessRequiresConvertToManagedRule).WithLocation(1).WithArguments("MarshallerType", MarshalMode.UnmanagedToManagedIn, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessRequiresConvertToManagedRule).WithLocation(2).WithArguments("MarshallerType", MarshalMode.ElementOut, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesBidirectionalShape_Missing_BothConvertMethods_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedRef, typeof({|#0:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedRef, typeof({|#1:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementRef, typeof({|#2:MarshallerType|}))]
+ static class MarshallerType
+ {
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessValueInRequiresConvertToUnmanagedRule).WithLocation(0).WithArguments("MarshallerType", MarshalMode.ManagedToUnmanagedRef, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessValueInRequiresConvertToUnmanagedRule).WithLocation(1).WithArguments("MarshallerType", MarshalMode.UnmanagedToManagedRef, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessValueInRequiresConvertToUnmanagedRule).WithLocation(2).WithArguments("MarshallerType", MarshalMode.ElementRef, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessRequiresConvertToManagedRule).WithLocation(0).WithArguments("MarshallerType", MarshalMode.ManagedToUnmanagedRef, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessRequiresConvertToManagedRule).WithLocation(1).WithArguments("MarshallerType", MarshalMode.UnmanagedToManagedRef, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessRequiresConvertToManagedRule).WithLocation(2).WithArguments("MarshallerType", MarshalMode.ElementRef, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task ModeThatUsesBidirectionalShape_MismatchedUnmanagedTypes_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedRef, typeof({|#0:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.UnmanagedToManagedRef, typeof({|#1:MarshallerType|}))]
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ElementRef, typeof({|#2:MarshallerType|}))]
+ static class MarshallerType
+ {
+ public static int ConvertToUnmanaged(ManagedType t) => default;
+ public static ManagedType ConvertToManaged(float f) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(FirstParameterMustMatchReturnTypeRule).WithLocation(0).WithArguments("MarshallerType.ConvertToManaged(float)", "MarshallerType.ConvertToUnmanaged(ManagedType)"),
+ VerifyCS.Diagnostic(FirstParameterMustMatchReturnTypeRule).WithLocation(1).WithArguments("MarshallerType.ConvertToManaged(float)", "MarshallerType.ConvertToUnmanaged(ManagedType)"),
+ VerifyCS.Diagnostic(FirstParameterMustMatchReturnTypeRule).WithLocation(2).WithArguments("MarshallerType.ConvertToManaged(float)", "MarshallerType.ConvertToUnmanaged(ManagedType)"));
+ }
+
+ [Fact]
+ public async Task DefaultMode_Missing_BothConvertMethods_ReportsDiagnostic()
+ {
+ string source = """
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.Default, typeof({|#0:MarshallerType|}))]
+ static class MarshallerType
+ {
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(StatelessValueInRequiresConvertToUnmanagedRule).WithSeverity(DiagnosticSeverity.Info).WithLocation(0).WithArguments("MarshallerType", MarshalMode.Default, "ManagedType"),
+ VerifyCS.Diagnostic(StatelessRequiresConvertToManagedRule).WithSeverity(DiagnosticSeverity.Info).WithLocation(0).WithArguments("MarshallerType", MarshalMode.Default, "ManagedType"));
+ }
+
+ [Fact]
+ public async Task CallerAllocatedBuffer_NoBufferSize_ReportsDiagnostic()
+ {
+ string source = """
+ using System;
+ using System.Runtime.InteropServices.Marshalling;
+
+ class ManagedType {}
+
+ [CustomMarshaller(typeof(ManagedType), MarshalMode.ManagedToUnmanagedIn, typeof({|#0:MarshallerType|}))]
+ static class MarshallerType
+ {
+ public static nint ConvertToUnmanaged(ManagedType m, Span<byte> b) => default;
+ }
+ """;
+
+ await VerifyCS.VerifyAnalyzerAsync(
+ source,
+ VerifyCS.Diagnostic(CallerAllocConstructorMustHaveBufferSizeRule).WithLocation(0).WithArguments("MarshallerType", "byte"));
+ }
+ }
+}
projects / platform / upstream / dotnet / runtime.git / commitdiff