From f8c8a309bcd3cf6cbddd5df39f11dfde51d788d8 Mon Sep 17 00:00:00 2001 From: Elinor Fung Date: Thu, 24 Mar 2022 10:55:35 -0700 Subject: [PATCH 1/2] Enable localization for LibraryImportGenerator --- .../gen/Directory.Build.props | 7 +- .../Analyzers/AnalyzerDiagnostics.cs | 3 +- .../ConvertToLibraryImportAnalyzer.cs | 7 +- .../Analyzers/ConvertToLibraryImportFixer.cs | 12 +- .../Analyzers/CustomTypeMarshallerAnalyzer.cs | 128 +-- .../Analyzers/CustomTypeMarshallerFixer.cs | 4 +- .../GeneratorDiagnostics.cs | 88 +- .../LibraryImportGenerator.cs | 4 +- .../LibraryImportGenerator.csproj | 16 +- .../Resources.Designer.cs | 999 ------------------ .../Strings.resx} | 0 .../Resources/xlf/Strings.cs.xlf | 529 ++++++++++ .../Resources/xlf/Strings.de.xlf | 529 ++++++++++ .../Resources/xlf/Strings.es.xlf | 529 ++++++++++ .../Resources/xlf/Strings.fr.xlf | 529 ++++++++++ .../Resources/xlf/Strings.it.xlf | 529 ++++++++++ .../Resources/xlf/Strings.ja.xlf | 529 ++++++++++ .../Resources/xlf/Strings.ko.xlf | 529 ++++++++++ .../Resources/xlf/Strings.pl.xlf | 529 ++++++++++ .../Resources/xlf/Strings.pt-BR.xlf | 529 ++++++++++ .../Resources/xlf/Strings.ru.xlf | 529 ++++++++++ .../Resources/xlf/Strings.tr.xlf | 529 ++++++++++ .../Resources/xlf/Strings.zh-Hans.xlf | 529 ++++++++++ .../Resources/xlf/Strings.zh-Hant.xlf | 529 ++++++++++ ...ributedMarshallingModelGeneratorFactory.cs | 17 +- .../ByValueContentsMarshalKindValidator.cs | 6 +- .../MarshalAsMarshallingGeneratorFactory.cs | 11 +- .../Marshalling/MarshallerHelpers.cs | 2 +- .../MarshallingAttributeInfo.cs | 20 +- .../Microsoft.Interop.SourceGeneration.csproj | 11 - .../Resources.Designer.cs | 387 ------- .../Strings.resx} | 0 .../Resources/xlf/Strings.cs.xlf | 142 +++ .../Resources/xlf/Strings.de.xlf | 142 +++ .../Resources/xlf/Strings.es.xlf | 142 +++ .../Resources/xlf/Strings.fr.xlf | 142 +++ .../Resources/xlf/Strings.it.xlf | 142 +++ .../Resources/xlf/Strings.ja.xlf | 142 +++ .../Resources/xlf/Strings.ko.xlf | 142 +++ .../Resources/xlf/Strings.pl.xlf | 142 +++ .../Resources/xlf/Strings.pt-BR.xlf | 142 +++ .../Resources/xlf/Strings.ru.xlf | 142 +++ .../Resources/xlf/Strings.tr.xlf | 142 +++ .../Resources/xlf/Strings.zh-Hans.xlf | 142 +++ .../Resources/xlf/Strings.zh-Hant.xlf | 142 +++ 45 files changed, 8881 insertions(+), 1564 deletions(-) delete mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources.Designer.cs rename src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/{Resources.resx => Resources/Strings.resx} (100%) create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.cs.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.de.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.es.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.fr.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.it.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ja.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ko.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pl.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pt-BR.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ru.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.tr.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hans.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hant.xlf delete mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources.Designer.cs rename src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/{Resources.resx => Resources/Strings.resx} (100%) create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.cs.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.de.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.es.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.fr.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.it.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ja.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ko.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pl.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pt-BR.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ru.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.tr.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hans.xlf create mode 100644 src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hant.xlf diff --git a/src/libraries/System.Runtime.InteropServices/gen/Directory.Build.props b/src/libraries/System.Runtime.InteropServices/gen/Directory.Build.props index b48a519271a14..1bc81cccf2603 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Directory.Build.props +++ b/src/libraries/System.Runtime.InteropServices/gen/Directory.Build.props @@ -1,11 +1,12 @@ - false - false true false - false + + + true + false diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/AnalyzerDiagnostics.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/AnalyzerDiagnostics.cs index e365435b742e4..9c403dd343006 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/AnalyzerDiagnostics.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/AnalyzerDiagnostics.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System; using Microsoft.CodeAnalysis; namespace Microsoft.Interop.Analyzers @@ -33,7 +34,7 @@ public static class Ids internal static LocalizableResourceString GetResourceString(string resourceName) { - return new LocalizableResourceString(resourceName, Resources.ResourceManager, typeof(Resources)); + return new LocalizableResourceString(resourceName, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.LibraryImportGenerator.SR)); } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs index 5d2d29be347a9..e499add9a2934 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System; using System.Collections.Generic; using System.Collections.Immutable; using System.Runtime.InteropServices; @@ -27,12 +28,12 @@ public class ConvertToLibraryImportAnalyzer : DiagnosticAnalyzer public static readonly DiagnosticDescriptor ConvertToLibraryImport = new DiagnosticDescriptor( Ids.ConvertToLibraryImport, - GetResourceString(nameof(Resources.ConvertToLibraryImportTitle)), - GetResourceString(nameof(Resources.ConvertToLibraryImportMessage)), + GetResourceString(nameof(SR.ConvertToLibraryImportTitle)), + GetResourceString(nameof(SR.ConvertToLibraryImportMessage)), Category, DiagnosticSeverity.Info, isEnabledByDefault: false, - description: GetResourceString(nameof(Resources.ConvertToLibraryImportDescription))); + description: GetResourceString(nameof(SR.ConvertToLibraryImportDescription))); public override ImmutableArray SupportedDiagnostics => ImmutableArray.Create(ConvertToLibraryImport); diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportFixer.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportFixer.cs index 4a15fb9cd1702..de0b671da168c 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportFixer.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportFixer.cs @@ -59,7 +59,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) // Register code fix context.RegisterCodeFix( CodeAction.Create( - Resources.ConvertToLibraryImport, + SR.ConvertToLibraryImport, cancelToken => ConvertToLibraryImport( context.Document, methodSyntax, @@ -81,7 +81,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( CodeAction.Create( - string.Format(Resources.ConvertToLibraryImportWithSuffix, "A"), + string.Format(SR.ConvertToLibraryImportWithSuffix, "A"), cancelToken => ConvertToLibraryImport( context.Document, methodSyntax, @@ -94,7 +94,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( CodeAction.Create( - string.Format(Resources.ConvertToLibraryImportWithSuffix, "W"), + string.Format(SR.ConvertToLibraryImportWithSuffix, "W"), cancelToken => ConvertToLibraryImport( context.Document, methodSyntax, @@ -135,7 +135,7 @@ private class CustomFixAllProvider : DocumentBasedFixAllProvider bool shouldWarn = await TransformCallersOfNoPreserveSigMethod(editor, methodSymbol, fixAllContext.CancellationToken).ConfigureAwait(false); if (shouldWarn) { - generatedDeclaration = generatedDeclaration.WithAdditionalAnnotations(WarningAnnotation.Create(Resources.ConvertNoPreserveSigDllImportToGeneratedMayProduceInvalidCode)); + generatedDeclaration = generatedDeclaration.WithAdditionalAnnotations(WarningAnnotation.Create(SR.ConvertNoPreserveSigDllImportToGeneratedMayProduceInvalidCode)); } } @@ -176,7 +176,7 @@ private static async Task ConvertToLibraryImport( bool shouldWarn = await TransformCallersOfNoPreserveSigMethod(editor, methodSymbol, cancellationToken).ConfigureAwait(false); if (shouldWarn) { - generatedDeclaration = generatedDeclaration.WithAdditionalAnnotations(WarningAnnotation.Create(Resources.ConvertNoPreserveSigDllImportToGeneratedMayProduceInvalidCode)); + generatedDeclaration = generatedDeclaration.WithAdditionalAnnotations(WarningAnnotation.Create(SR.ConvertNoPreserveSigDllImportToGeneratedMayProduceInvalidCode)); } } @@ -221,7 +221,7 @@ private static async Task ConvertMethodDeclarationToLibraryImport( // Add annotation about potential behavioural and compatibility changes libraryImportSyntax = libraryImportSyntax.WithAdditionalAnnotations( - WarningAnnotation.Create(string.Format(Resources.ConvertToLibraryImportWarning, "[TODO] Documentation link"))); + WarningAnnotation.Create(string.Format(SR.ConvertToLibraryImportWarning, "[TODO] Documentation link"))); // Replace DllImport with LibraryImport SyntaxNode generatedDeclaration = generator.ReplaceNode(methodSyntax, dllImportSyntax, libraryImportSyntax); diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerAnalyzer.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerAnalyzer.cs index d9889c941c838..3e463141ab05a 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerAnalyzer.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerAnalyzer.cs @@ -36,321 +36,321 @@ public static class MissingMemberNames new DiagnosticDescriptor( Ids.MarshallerTypeMustSpecifyManagedType, "MarshallerTypeMustSpecifyManagedType", - GetResourceString(nameof(Resources.MarshallerTypeMustSpecifyManagedTypeMessage)), + GetResourceString(nameof(SR.MarshallerTypeMustSpecifyManagedTypeMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.MarshallerTypeMustSpecifyManagedTypeDescription))); + description: GetResourceString(nameof(SR.MarshallerTypeMustSpecifyManagedTypeDescription))); public static readonly DiagnosticDescriptor CustomTypeMarshallerAttributeMustBeValidRule = new DiagnosticDescriptor( Ids.CustomTypeMarshallerAttributeMustBeValid, "CustomTypeMarshallerAttributeMustBeValid", - GetResourceString(nameof(Resources.CustomTypeMarshallerAttributeMustBeValidMessage)), + GetResourceString(nameof(SR.CustomTypeMarshallerAttributeMustBeValidMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.CustomTypeMarshallerAttributeMustBeValidDescription))); + description: GetResourceString(nameof(SR.CustomTypeMarshallerAttributeMustBeValidDescription))); public static readonly DiagnosticDescriptor MarshallerKindMustBeValidRule = new DiagnosticDescriptor( Ids.CustomTypeMarshallerAttributeMustBeValid, "CustomTypeMarshallerAttributeMustBeValid", - GetResourceString(nameof(Resources.MarshallerKindMustBeValidMessage)), + GetResourceString(nameof(SR.MarshallerKindMustBeValidMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.MarshallerKindMustBeValidDescription))); + description: GetResourceString(nameof(SR.MarshallerKindMustBeValidDescription))); public static readonly DiagnosticDescriptor MarshallerDirectionMustBeValidRule = new DiagnosticDescriptor( Ids.CustomTypeMarshallerAttributeMustBeValid, "CustomTypeMarshallerAttributeMustBeValid", - GetResourceString(nameof(Resources.MarshallerDirectionMustBeValidMessage)), + GetResourceString(nameof(SR.MarshallerDirectionMustBeValidMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.MarshallerDirectionMustBeValidDescription))); + description: GetResourceString(nameof(SR.MarshallerDirectionMustBeValidDescription))); public static readonly DiagnosticDescriptor NativeTypeMustHaveCustomTypeMarshallerAttributeRule = new DiagnosticDescriptor( Ids.InvalidNativeType, "InvalidNativeType", - GetResourceString(nameof(Resources.NativeTypeMustHaveCustomTypeMarshallerAttributeMessage)), + GetResourceString(nameof(SR.NativeTypeMustHaveCustomTypeMarshallerAttributeMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.NativeTypeMustHaveCustomTypeMarshallerAttributeDescription))); + description: GetResourceString(nameof(SR.NativeTypeMustHaveCustomTypeMarshallerAttributeDescription))); public static readonly DiagnosticDescriptor NativeTypeMustBeBlittableRule = new DiagnosticDescriptor( Ids.InvalidNativeType, "InvalidNativeType", - GetResourceString(nameof(Resources.NativeTypeMustBeBlittableMessage)), + GetResourceString(nameof(SR.NativeTypeMustBeBlittableMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.NativeTypeMustBeBlittableDescription))); + description: GetResourceString(nameof(SR.NativeTypeMustBeBlittableDescription))); public static readonly DiagnosticDescriptor GetPinnableReferenceReturnTypeBlittableRule = new DiagnosticDescriptor( Ids.GetPinnableReferenceReturnTypeBlittable, "GetPinnableReferenceReturnTypeBlittable", - GetResourceString(nameof(Resources.GetPinnableReferenceReturnTypeBlittableMessage)), + GetResourceString(nameof(SR.GetPinnableReferenceReturnTypeBlittableMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.GetPinnableReferenceReturnTypeBlittableDescription))); + description: GetResourceString(nameof(SR.GetPinnableReferenceReturnTypeBlittableDescription))); public static readonly DiagnosticDescriptor NativeTypeMustBePointerSizedRule = new DiagnosticDescriptor( Ids.InvalidNativeType, "InvalidNativeType", - GetResourceString(nameof(Resources.NativeTypeMustBePointerSizedMessage)), + GetResourceString(nameof(SR.NativeTypeMustBePointerSizedMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.NativeTypeMustBePointerSizedDescription))); + description: GetResourceString(nameof(SR.NativeTypeMustBePointerSizedDescription))); public static readonly DiagnosticDescriptor CustomMarshallerTypeMustSupportDirectionRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustSupportDirection, "CustomMarshallerTypeMustSupportDirection", - GetResourceString(nameof(Resources.CustomMarshallerTypeMustSupportDirectionMessage)), + GetResourceString(nameof(SR.CustomMarshallerTypeMustSupportDirectionMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.CustomMarshallerTypeMustSupportDirectionDescription))); + description: GetResourceString(nameof(SR.CustomMarshallerTypeMustSupportDirectionDescription))); public static readonly DiagnosticDescriptor ValueInRequiresOneParameterConstructorRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.ValueInRequiresOneParameterConstructorMessage)), + GetResourceString(nameof(SR.ValueInRequiresOneParameterConstructorMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ValueInRequiresOneParameterConstructorDescription))); + description: GetResourceString(nameof(SR.ValueInRequiresOneParameterConstructorDescription))); public static readonly DiagnosticDescriptor LinearCollectionInRequiresTwoParameterConstructorRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.LinearCollectionInRequiresTwoParameterConstructorMessage)), + GetResourceString(nameof(SR.LinearCollectionInRequiresTwoParameterConstructorMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.LinearCollectionInRequiresTwoParameterConstructorDescription))); + description: GetResourceString(nameof(SR.LinearCollectionInRequiresTwoParameterConstructorDescription))); public static readonly DiagnosticDescriptor ValueInCallerAllocatedBufferRequiresSpanConstructorRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.ValueInCallerAllocatedBufferRequiresSpanConstructorMessage)), + GetResourceString(nameof(SR.ValueInCallerAllocatedBufferRequiresSpanConstructorMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ValueInCallerAllocatedBufferRequiresSpanConstructorDescription))); + description: GetResourceString(nameof(SR.ValueInCallerAllocatedBufferRequiresSpanConstructorDescription))); public static readonly DiagnosticDescriptor LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorMessage)), + GetResourceString(nameof(SR.LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorDescription))); + description: GetResourceString(nameof(SR.LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorDescription))); public static readonly DiagnosticDescriptor OutRequiresToManagedRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.OutRequiresToManagedMessage)), + GetResourceString(nameof(SR.OutRequiresToManagedMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.OutRequiresToManagedDescription))); + description: GetResourceString(nameof(SR.OutRequiresToManagedDescription))); public static readonly DiagnosticDescriptor LinearCollectionInRequiresCollectionMethodsRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.LinearCollectionInRequiresCollectionMethodsMessage)), + GetResourceString(nameof(SR.LinearCollectionInRequiresCollectionMethodsMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.LinearCollectionInRequiresCollectionMethodsDescription))); + description: GetResourceString(nameof(SR.LinearCollectionInRequiresCollectionMethodsDescription))); public static readonly DiagnosticDescriptor LinearCollectionOutRequiresCollectionMethodsRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.LinearCollectionOutRequiresCollectionMethodsMessage)), + GetResourceString(nameof(SR.LinearCollectionOutRequiresCollectionMethodsMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.LinearCollectionOutRequiresCollectionMethodsDescription))); + description: GetResourceString(nameof(SR.LinearCollectionOutRequiresCollectionMethodsDescription))); public static readonly DiagnosticDescriptor LinearCollectionOutRequiresIntConstructorRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.LinearCollectionOutRequiresIntConstructorMessage)), + GetResourceString(nameof(SR.LinearCollectionOutRequiresIntConstructorMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.LinearCollectionOutRequiresIntConstructorDescription))); + description: GetResourceString(nameof(SR.LinearCollectionOutRequiresIntConstructorDescription))); public static readonly DiagnosticDescriptor UnmanagedResourcesRequiresFreeNativeRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.UnmanagedResourcesRequiresFreeNativeMessage)), + GetResourceString(nameof(SR.UnmanagedResourcesRequiresFreeNativeMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.UnmanagedResourcesRequiresFreeNativeDescription))); + description: GetResourceString(nameof(SR.UnmanagedResourcesRequiresFreeNativeDescription))); public static readonly DiagnosticDescriptor OutTwoStageMarshallingRequiresFromNativeValueRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.OutTwoStageMarshallingRequiresFromNativeValueMessage)), + GetResourceString(nameof(SR.OutTwoStageMarshallingRequiresFromNativeValueMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.OutTwoStageMarshallingRequiresFromNativeValueDescription))); + description: GetResourceString(nameof(SR.OutTwoStageMarshallingRequiresFromNativeValueDescription))); public static readonly DiagnosticDescriptor InTwoStageMarshallingRequiresToNativeValueRule = new DiagnosticDescriptor( Ids.CustomMarshallerTypeMustHaveRequiredShape, "CustomMarshallerTypeMustHaveRequiredShape", - GetResourceString(nameof(Resources.InTwoStageMarshallingRequiresToNativeValueMessage)), + GetResourceString(nameof(SR.InTwoStageMarshallingRequiresToNativeValueMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.InTwoStageMarshallingRequiresToNativeValueDescription))); + description: GetResourceString(nameof(SR.InTwoStageMarshallingRequiresToNativeValueDescription))); public static readonly DiagnosticDescriptor GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackRule = new DiagnosticDescriptor( Ids.MissingAllocatingMarshallingFallback, "GetPinnableReferenceShouldSupportAllocatingMarshallingFallback", - GetResourceString(nameof(Resources.GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackMessage)), + GetResourceString(nameof(SR.GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackDescription))); + description: GetResourceString(nameof(SR.GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackDescription))); public static readonly DiagnosticDescriptor CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackRule = new DiagnosticDescriptor( Ids.MissingAllocatingMarshallingFallback, "CallerAllocMarshallingShouldSupportAllocatingMarshallingFallback", - GetResourceString(nameof(Resources.CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackMessage)), + GetResourceString(nameof(SR.CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackDescription))); + description: GetResourceString(nameof(SR.CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackDescription))); public static readonly DiagnosticDescriptor CallerAllocConstructorMustHaveBufferSizeRule = new DiagnosticDescriptor( Ids.CallerAllocConstructorMustHaveBufferSize, "CallerAllocConstructorMustHaveBufferSize", - GetResourceString(nameof(Resources.CallerAllocConstructorMustHaveBufferSizeMessage)), + GetResourceString(nameof(SR.CallerAllocConstructorMustHaveBufferSizeMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.CallerAllocConstructorMustHaveBufferSizeDescription))); + description: GetResourceString(nameof(SR.CallerAllocConstructorMustHaveBufferSizeDescription))); public static readonly DiagnosticDescriptor RefNativeValueUnsupportedRule = new DiagnosticDescriptor( Ids.InvalidSignaturesInMarshallerShape, "InvalidSignaturesInMarshallerShape", - GetResourceString(nameof(Resources.RefNativeValueUnsupportedMessage)), + GetResourceString(nameof(SR.RefNativeValueUnsupportedMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.RefNativeValueUnsupportedDescription))); + description: GetResourceString(nameof(SR.RefNativeValueUnsupportedDescription))); public static readonly DiagnosticDescriptor NativeGenericTypeMustBeClosedOrMatchArityRule = new DiagnosticDescriptor( Ids.InvalidNativeType, "NativeGenericTypeMustBeClosedOrMatchArity", - GetResourceString(nameof(Resources.NativeGenericTypeMustBeClosedOrMatchArityMessage)), + GetResourceString(nameof(SR.NativeGenericTypeMustBeClosedOrMatchArityMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.NativeGenericTypeMustBeClosedOrMatchArityDescription))); + description: GetResourceString(nameof(SR.NativeGenericTypeMustBeClosedOrMatchArityDescription))); public static readonly DiagnosticDescriptor MarshallerGetPinnableReferenceRequiresTwoStageMarshallingRule = new DiagnosticDescriptor( Ids.MarshallerGetPinnableReferenceRequiresTwoStageMarshalling, "MarshallerGetPinnableReferenceRequiresTwoStageMarshalling", - GetResourceString(nameof(Resources.MarshallerGetPinnableReferenceRequiresTwoStageMarshallingMessage)), + GetResourceString(nameof(SR.MarshallerGetPinnableReferenceRequiresTwoStageMarshallingMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.MarshallerGetPinnableReferenceRequiresTwoStageMarshallingDescription))); + description: GetResourceString(nameof(SR.MarshallerGetPinnableReferenceRequiresTwoStageMarshallingDescription))); public static readonly DiagnosticDescriptor FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureRule = new DiagnosticDescriptor( Ids.ProvidedMethodsNotSpecifiedInShape, "ProvidedMethodsNotSpecifiedInShape", - GetResourceString(nameof(Resources.FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureMessage)), + GetResourceString(nameof(SR.FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureDescription))); + description: GetResourceString(nameof(SR.FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureDescription))); public static readonly DiagnosticDescriptor ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureRule = new DiagnosticDescriptor( Ids.ProvidedMethodsNotSpecifiedInShape, "ProvidedMethodsNotSpecifiedInShape", - GetResourceString(nameof(Resources.ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage)), + GetResourceString(nameof(SR.ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription))); + description: GetResourceString(nameof(SR.ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription))); public static readonly DiagnosticDescriptor FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureRule = new DiagnosticDescriptor( Ids.ProvidedMethodsNotSpecifiedInShape, "ProvidedMethodsNotSpecifiedInShape", - GetResourceString(nameof(Resources.FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage)), + GetResourceString(nameof(SR.FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription))); + description: GetResourceString(nameof(SR.FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription))); public static readonly DiagnosticDescriptor CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureRule = new DiagnosticDescriptor( Ids.ProvidedMethodsNotSpecifiedInShape, "ProvidedMethodsNotSpecifiedInShape", - GetResourceString(nameof(Resources.CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureMessage)), + GetResourceString(nameof(SR.CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureDescription))); + description: GetResourceString(nameof(SR.CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureDescription))); public static readonly DiagnosticDescriptor TwoStageMarshallingNativeTypesMustMatchRule = new DiagnosticDescriptor( Ids.InvalidSignaturesInMarshallerShape, "InvalidSignaturesInMarshallerShape", - GetResourceString(nameof(Resources.TwoStageMarshallingNativeTypesMustMatchMessage)), + GetResourceString(nameof(SR.TwoStageMarshallingNativeTypesMustMatchMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.TwoStageMarshallingNativeTypesMustMatchDescription))); + description: GetResourceString(nameof(SR.TwoStageMarshallingNativeTypesMustMatchDescription))); public static readonly DiagnosticDescriptor LinearCollectionElementTypesMustMatchRule = new DiagnosticDescriptor( Ids.InvalidSignaturesInMarshallerShape, "InvalidSignaturesInMarshallerShape", - GetResourceString(nameof(Resources.LinearCollectionElementTypesMustMatchMessage)), + GetResourceString(nameof(SR.LinearCollectionElementTypesMustMatchMessage)), Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.LinearCollectionElementTypesMustMatchDescription))); + description: GetResourceString(nameof(SR.LinearCollectionElementTypesMustMatchDescription))); public override ImmutableArray SupportedDiagnostics => ImmutableArray.Create( diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerFixer.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerFixer.cs index 08cc2550ed4e2..4341e26c1ad4a 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerFixer.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/CustomTypeMarshallerFixer.cs @@ -115,7 +115,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( CodeAction.Create( - Resources.AddMissingCustomTypeMarshallerMembers, + SR.AddMissingCustomTypeMarshallerMembers, ct => AddMissingMembers(doc, node, missingMemberNames, ct), AddMissingCustomTypeMarshallerMembersKey), missingMembersDiagnostics); @@ -127,7 +127,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( CodeAction.Create( - Resources.AddMissingFeaturesToCustomTypeMarshaller, + SR.AddMissingFeaturesToCustomTypeMarshaller, ct => AddMissingFeatures(doc, node, featuresToAdd, ct), AddMissingCustomTypeMarshallerFeaturesKey), featuresToAddDiagnostics); diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/GeneratorDiagnostics.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/GeneratorDiagnostics.cs index 56589707b9f68..8908b9068faff 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/GeneratorDiagnostics.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/GeneratorDiagnostics.cs @@ -30,142 +30,142 @@ public class Ids public static readonly DiagnosticDescriptor InvalidAttributedMethodSignature = new DiagnosticDescriptor( Ids.InvalidLibraryImportAttributeUsage, - GetResourceString(nameof(Resources.InvalidLibraryImportAttributeUsageTitle)), - GetResourceString(nameof(Resources.InvalidAttributedMethodSignatureMessage)), + GetResourceString(nameof(SR.InvalidLibraryImportAttributeUsageTitle)), + GetResourceString(nameof(SR.InvalidAttributedMethodSignatureMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.InvalidAttributedMethodDescription))); + description: GetResourceString(nameof(SR.InvalidAttributedMethodDescription))); public static readonly DiagnosticDescriptor InvalidAttributedMethodContainingTypeMissingModifiers = new DiagnosticDescriptor( Ids.InvalidLibraryImportAttributeUsage, - GetResourceString(nameof(Resources.InvalidLibraryImportAttributeUsageTitle)), - GetResourceString(nameof(Resources.InvalidAttributedMethodContainingTypeMissingModifiersMessage)), + GetResourceString(nameof(SR.InvalidLibraryImportAttributeUsageTitle)), + GetResourceString(nameof(SR.InvalidAttributedMethodContainingTypeMissingModifiersMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.InvalidAttributedMethodDescription))); + description: GetResourceString(nameof(SR.InvalidAttributedMethodDescription))); public static readonly DiagnosticDescriptor InvalidStringMarshallingConfiguration = new DiagnosticDescriptor( Ids.InvalidLibraryImportAttributeUsage, - GetResourceString(nameof(Resources.InvalidLibraryImportAttributeUsageTitle)), - GetResourceString(nameof(Resources.InvalidStringMarshallingConfigurationMessage)), + GetResourceString(nameof(SR.InvalidLibraryImportAttributeUsageTitle)), + GetResourceString(nameof(SR.InvalidStringMarshallingConfigurationMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.InvalidStringMarshallingConfigurationDescription))); + description: GetResourceString(nameof(SR.InvalidStringMarshallingConfigurationDescription))); public static readonly DiagnosticDescriptor ParameterTypeNotSupported = new DiagnosticDescriptor( Ids.TypeNotSupported, - GetResourceString(nameof(Resources.TypeNotSupportedTitle)), - GetResourceString(nameof(Resources.TypeNotSupportedMessageParameter)), + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageParameter)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.TypeNotSupportedDescription))); + description: GetResourceString(nameof(SR.TypeNotSupportedDescription))); public static readonly DiagnosticDescriptor ReturnTypeNotSupported = new DiagnosticDescriptor( Ids.TypeNotSupported, - GetResourceString(nameof(Resources.TypeNotSupportedTitle)), - GetResourceString(nameof(Resources.TypeNotSupportedMessageReturn)), + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageReturn)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.TypeNotSupportedDescription))); + description: GetResourceString(nameof(SR.TypeNotSupportedDescription))); public static readonly DiagnosticDescriptor ParameterTypeNotSupportedWithDetails = new DiagnosticDescriptor( Ids.TypeNotSupported, - GetResourceString(nameof(Resources.TypeNotSupportedTitle)), - GetResourceString(nameof(Resources.TypeNotSupportedMessageParameterWithDetails)), + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageParameterWithDetails)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.TypeNotSupportedDescription))); + description: GetResourceString(nameof(SR.TypeNotSupportedDescription))); public static readonly DiagnosticDescriptor ReturnTypeNotSupportedWithDetails = new DiagnosticDescriptor( Ids.TypeNotSupported, - GetResourceString(nameof(Resources.TypeNotSupportedTitle)), - GetResourceString(nameof(Resources.TypeNotSupportedMessageReturnWithDetails)), + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageReturnWithDetails)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.TypeNotSupportedDescription))); + description: GetResourceString(nameof(SR.TypeNotSupportedDescription))); public static readonly DiagnosticDescriptor ParameterConfigurationNotSupported = new DiagnosticDescriptor( Ids.ConfigurationNotSupported, - GetResourceString(nameof(Resources.ConfigurationNotSupportedTitle)), - GetResourceString(nameof(Resources.ConfigurationNotSupportedMessageParameter)), + GetResourceString(nameof(SR.ConfigurationNotSupportedTitle)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageParameter)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ConfigurationNotSupportedDescription))); + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescription))); public static readonly DiagnosticDescriptor ReturnConfigurationNotSupported = new DiagnosticDescriptor( Ids.ConfigurationNotSupported, - GetResourceString(nameof(Resources.ConfigurationNotSupportedTitle)), - GetResourceString(nameof(Resources.ConfigurationNotSupportedMessageReturn)), + GetResourceString(nameof(SR.ConfigurationNotSupportedTitle)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageReturn)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ConfigurationNotSupportedDescription))); + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescription))); public static readonly DiagnosticDescriptor ConfigurationNotSupported = new DiagnosticDescriptor( Ids.ConfigurationNotSupported, - GetResourceString(nameof(Resources.ConfigurationNotSupportedTitle)), - GetResourceString(nameof(Resources.ConfigurationNotSupportedMessage)), + GetResourceString(nameof(SR.ConfigurationNotSupportedTitle)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ConfigurationNotSupportedDescription))); + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescription))); public static readonly DiagnosticDescriptor ConfigurationValueNotSupported = new DiagnosticDescriptor( Ids.ConfigurationNotSupported, - GetResourceString(nameof(Resources.ConfigurationNotSupportedTitle)), - GetResourceString(nameof(Resources.ConfigurationNotSupportedMessageValue)), + GetResourceString(nameof(SR.ConfigurationNotSupportedTitle)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageValue)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ConfigurationNotSupportedDescription))); + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescription))); public static readonly DiagnosticDescriptor MarshallingAttributeConfigurationNotSupported = new DiagnosticDescriptor( Ids.ConfigurationNotSupported, - GetResourceString(nameof(Resources.ConfigurationNotSupportedTitle)), - GetResourceString(nameof(Resources.ConfigurationNotSupportedMessageMarshallingInfo)), + GetResourceString(nameof(SR.ConfigurationNotSupportedTitle)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageMarshallingInfo)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.ConfigurationNotSupportedDescription))); + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescription))); public static readonly DiagnosticDescriptor TargetFrameworkNotSupported = new DiagnosticDescriptor( Ids.TargetFrameworkNotSupported, - GetResourceString(nameof(Resources.TargetFrameworkNotSupportedTitle)), - GetResourceString(nameof(Resources.TargetFrameworkNotSupportedMessage)), + GetResourceString(nameof(SR.TargetFrameworkNotSupportedTitle)), + GetResourceString(nameof(SR.TargetFrameworkNotSupportedMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.TargetFrameworkNotSupportedDescription))); + description: GetResourceString(nameof(SR.TargetFrameworkNotSupportedDescription))); public static readonly DiagnosticDescriptor CannotForwardToDllImport = new DiagnosticDescriptor( Ids.CannotForwardToDllImport, - GetResourceString(nameof(Resources.CannotForwardToDllImportTitle)), - GetResourceString(nameof(Resources.CannotForwardToDllImportMessage)), + GetResourceString(nameof(SR.CannotForwardToDllImportTitle)), + GetResourceString(nameof(SR.CannotForwardToDllImportMessage)), Category, DiagnosticSeverity.Error, isEnabledByDefault: true, - description: GetResourceString(nameof(Resources.CannotForwardToDllImportDescription))); + description: GetResourceString(nameof(SR.CannotForwardToDllImportDescription))); private readonly List _diagnostics = new List(); @@ -316,7 +316,7 @@ public void ReportInvalidMarshallingAttributeInfo( _diagnostics.Add( attributeData.CreateDiagnostic( GeneratorDiagnostics.MarshallingAttributeConfigurationNotSupported, - new LocalizableResourceString(reasonResourceName, Resources.ResourceManager, typeof(Resources), reasonArgs))); + new LocalizableResourceString(reasonResourceName, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.LibraryImportGenerator.SR), reasonArgs))); } /// @@ -349,7 +349,7 @@ public void ReportCannotForwardToDllImport(MethodDeclarationSyntax method, strin private static LocalizableResourceString GetResourceString(string resourceName) { - return new LocalizableResourceString(resourceName, Resources.ResourceManager, typeof(Resources)); + return new LocalizableResourceString(resourceName, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.LibraryImportGenerator.SR)); } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs index 1040ca2e45084..b5e1a79da2d1b 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs @@ -459,14 +459,14 @@ private static IncrementalStubGenerationContext CalculateStubInformation(IMethod if (libraryImportData.StringMarshalling == StringMarshalling.Custom && libraryImportData.StringMarshallingCustomType is null) { generatorDiagnostics.ReportInvalidStringMarshallingConfiguration( - generatedDllImportAttr, symbol.Name, Resources.InvalidStringMarshallingConfigurationMissingCustomType); + generatedDllImportAttr, symbol.Name, SR.InvalidStringMarshallingConfigurationMissingCustomType); } // User specified something other than StringMarshalling.Custom while specifying StringMarshallingCustomType if (libraryImportData.StringMarshalling != StringMarshalling.Custom && libraryImportData.StringMarshallingCustomType is not null) { generatorDiagnostics.ReportInvalidStringMarshallingConfiguration( - generatedDllImportAttr, symbol.Name, Resources.InvalidStringMarshallingConfigurationNotCustom); + generatedDllImportAttr, symbol.Name, SR.InvalidStringMarshallingConfigurationNotCustom); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj index 467bf762702b2..19c0adfe5ae8c 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj @@ -12,6 +12,7 @@ RS2008;$(NoWarn) + cs @@ -21,8 +22,6 @@ https://github.com/dotnet/runtime/tree/main/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator LibraryImportGenerator LibraryImportGenerator, analyzers - - true @@ -30,19 +29,6 @@ - - - - - - - - diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources.Designer.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources.Designer.cs deleted file mode 100644 index 5e4628b58dde0..0000000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources.Designer.cs +++ /dev/null @@ -1,999 +0,0 @@ -//------------------------------------------------------------------------------ -// -// This code was generated by a tool. -// Runtime Version:4.0.30319.42000 -// -// Changes to this file may cause incorrect behavior and will be lost if -// the code is regenerated. -// -//------------------------------------------------------------------------------ - -namespace Microsoft.Interop { - using System; - - - /// - /// A strongly-typed resource class, for looking up localized strings, etc. - /// - // This class was auto-generated by the StronglyTypedResourceBuilder - // class via a tool like ResGen or Visual Studio. - // To add or remove a member, edit your .ResX file then rerun ResGen - // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] - [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] - [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] - internal class Resources { - - private static global::System.Resources.ResourceManager resourceMan; - - private static global::System.Globalization.CultureInfo resourceCulture; - - [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] - internal Resources() { - } - - /// - /// Returns the cached ResourceManager instance used by this class. - /// - [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Resources.ResourceManager ResourceManager { - get { - if (object.ReferenceEquals(resourceMan, null)) { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Interop.Resources", typeof(Resources).Assembly); - resourceMan = temp; - } - return resourceMan; - } - } - - /// - /// Overrides the current thread's CurrentUICulture property for all - /// resource lookups using this strongly typed resource class. - /// - [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Globalization.CultureInfo Culture { - get { - return resourceCulture; - } - set { - resourceCulture = value; - } - } - - /// - /// Looks up a localized string similar to Add missing custom type marshaller members. - /// - internal static string AddMissingCustomTypeMarshallerMembers { - get { - return ResourceManager.GetString("AddMissingCustomTypeMarshallerMembers", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Add missing features to the 'CustomTypeMarshallerAttribute' attribute. - /// - internal static string AddMissingFeaturesToCustomTypeMarshaller { - get { - return ResourceManager.GetString("AddMissingFeaturesToCustomTypeMarshaller", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature.. - /// - internal static string CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureDescription { - get { - return ResourceManager.GetString("CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified.. - /// - internal static string CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureMessage { - get { - return ResourceManager.GetString("CallerAllocatedBufferConstructorProvidedShouldSpecifyFeatureMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer.. - /// - internal static string CallerAllocConstructorMustHaveBufferSizeDescription { - get { - return ResourceManager.GetString("CallerAllocConstructorMustHaveBufferSizeDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>'. - /// - internal static string CallerAllocConstructorMustHaveBufferSizeMessage { - get { - return ResourceManager.GetString("CallerAllocConstructorMustHaveBufferSizeMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible.. - /// - internal static string CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackDescription { - get { - return ResourceManager.GetString("CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible. - /// - internal static string CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackMessage { - get { - return ResourceManager.GetString("CallerAllocMarshallingShouldSupportAllocatingMarshallingFallbackMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The generated 'DllImportAttribute' will not have a value corresponding to '{0}'.. - /// - internal static string CannotForwardToDllImportDescription { - get { - return ResourceManager.GetString("CannotForwardToDllImportDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded. - /// - internal static string CannotForwardToDllImportMessage { - get { - return ResourceManager.GetString("CannotForwardToDllImportMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute'. - /// - internal static string CannotForwardToDllImportTitle { - get { - return ResourceManager.GetString("CannotForwardToDllImportTitle", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Source-generated P/Invokes will ignore any configuration that is not supported.. - /// - internal static string ConfigurationNotSupportedDescription { - get { - return ResourceManager.GetString("ConfigurationNotSupportedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.. - /// - internal static string ConfigurationNotSupportedMessage { - get { - return ResourceManager.GetString("ConfigurationNotSupportedMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified marshalling configuration is not supported by source-generated P/Invokes. {0}.. - /// - internal static string ConfigurationNotSupportedMessageMarshallingInfo { - get { - return ResourceManager.GetString("ConfigurationNotSupportedMessageMarshallingInfo", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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.. - /// - internal static string ConfigurationNotSupportedMessageParameter { - get { - return ResourceManager.GetString("ConfigurationNotSupportedMessageParameter", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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.. - /// - internal static string ConfigurationNotSupportedMessageReturn { - get { - return ResourceManager.GetString("ConfigurationNotSupportedMessageReturn", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead.. - /// - internal static string ConfigurationNotSupportedMessageValue { - get { - return ResourceManager.GetString("ConfigurationNotSupportedMessageValue", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Specified configuration is not supported by source-generated P/Invokes.. - /// - internal static string ConfigurationNotSupportedTitle { - get { - return ResourceManager.GetString("ConfigurationNotSupportedTitle", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth'. - /// - internal static string ConstantAndElementCountInfoDisallowed { - get { - return ResourceManager.GetString("ConstantAndElementCountInfoDisallowed", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code. - /// - internal static string ConvertNoPreserveSigDllImportToGeneratedMayProduceInvalidCode { - get { - return ResourceManager.GetString("ConvertNoPreserveSigDllImportToGeneratedMayProduceInvalidCode", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Convert to 'LibraryImport'. - /// - internal static string ConvertToLibraryImport { - get { - return ResourceManager.GetString("ConvertToLibraryImport", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time. - /// - internal static string ConvertToLibraryImportDescription { - get { - return ResourceManager.GetString("ConvertToLibraryImportDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time. - /// - internal static string ConvertToLibraryImportMessage { - get { - return ResourceManager.GetString("ConvertToLibraryImportMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time. - /// - internal static string ConvertToLibraryImportTitle { - get { - return ResourceManager.GetString("ConvertToLibraryImportTitle", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information.. - /// - internal static string ConvertToLibraryImportWarning { - get { - return ResourceManager.GetString("ConvertToLibraryImportWarning", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Convert to 'LibraryImport' with '{0}' suffix. - /// - internal static string ConvertToLibraryImportWithSuffix { - get { - return ResourceManager.GetString("ConvertToLibraryImportWithSuffix", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum. - /// - internal static string CustomMarshallerTypeMustSupportDirectionDescription { - get { - return ResourceManager.GetString("CustomMarshallerTypeMustSupportDirectionDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum. - /// - internal static string CustomMarshallerTypeMustSupportDirectionMessage { - get { - return ResourceManager.GetString("CustomMarshallerTypeMustSupportDirectionMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'CustomTypeMarshallerAttribute' attribute must be semantically valid. - /// - internal static string CustomTypeMarshallerAttributeMustBeValidDescription { - get { - return ResourceManager.GetString("CustomTypeMarshallerAttributeMustBeValidDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid. - /// - internal static string CustomTypeMarshallerAttributeMustBeValidMessage { - get { - return ResourceManager.GetString("CustomTypeMarshallerAttributeMustBeValidMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it.. - /// - internal static string CustomTypeMarshallingManagedToNativeUnsupported { - get { - return ResourceManager.GetString("CustomTypeMarshallingManagedToNativeUnsupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it.. - /// - internal static string CustomTypeMarshallingNativeToManagedUnsupported { - get { - return ResourceManager.GetString("CustomTypeMarshallingNativeToManagedUnsupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature.. - /// - internal static string FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureDescription { - get { - return ResourceManager.GetString("FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified.. - /// - internal static string FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureMessage { - get { - return ResourceManager.GetString("FreeNativeMethodProvidedShouldSpecifyUnmanagedResourcesFeatureMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature.. - /// - internal static string FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription { - get { - return ResourceManager.GetString("FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified.. - /// - internal static string FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage { - get { - return ResourceManager.GetString("FromNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable.. - /// - internal static string GetPinnableReferenceReturnTypeBlittableDescription { - get { - return ResourceManager.GetString("GetPinnableReferenceReturnTypeBlittableDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable. - /// - internal static string GetPinnableReferenceReturnTypeBlittableMessage { - get { - return ResourceManager.GetString("GetPinnableReferenceReturnTypeBlittableMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible.. - /// - internal static string GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackDescription { - get { - return ResourceManager.GetString("GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible. - /// - internal static string GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackMessage { - get { - return ResourceManager.GetString("GetPinnableReferenceShouldSupportAllocatingMarshallingFallbackMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction.. - /// - internal static string InTwoStageMarshallingRequiresToNativeValueDescription { - get { - return ResourceManager.GetString("InTwoStageMarshallingRequiresToNativeValueDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value. - /// - internal static string InTwoStageMarshallingRequiresToNativeValueMessage { - get { - return ResourceManager.GetString("InTwoStageMarshallingRequiresToNativeValueMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'.. - /// - internal static string InvalidAttributedMethodContainingTypeMissingModifiersMessage { - get { - return ResourceManager.GetString("InvalidAttributedMethodContainingTypeMissingModifiersMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic.. - /// - internal static string InvalidAttributedMethodDescription { - get { - return ResourceManager.GetString("InvalidAttributedMethodDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'.. - /// - internal static string InvalidAttributedMethodSignatureMessage { - get { - return ResourceManager.GetString("InvalidAttributedMethodSignatureMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Invalid 'LibraryImportAttribute' usage. - /// - internal static string InvalidLibraryImportAttributeUsageTitle { - get { - return ResourceManager.GetString("InvalidLibraryImportAttributeUsageTitle", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid.. - /// - internal static string InvalidStringMarshallingConfigurationDescription { - get { - return ResourceManager.GetString("InvalidStringMarshallingConfigurationDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1}. - /// - internal static string InvalidStringMarshallingConfigurationMessage { - get { - return ResourceManager.GetString("InvalidStringMarshallingConfigurationMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'.. - /// - internal static string InvalidStringMarshallingConfigurationMissingCustomType { - get { - return ResourceManager.GetString("InvalidStringMarshallingConfigurationMissingCustomType", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified.. - /// - internal static string InvalidStringMarshallingConfigurationNotCustom { - get { - return ResourceManager.GetString("InvalidStringMarshallingConfigurationNotCustom", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'.. - /// - internal static string LinearCollectionElementTypesMustMatchDescription { - get { - return ResourceManager.GetString("LinearCollectionElementTypesMustMatchDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. - /// - internal static string LinearCollectionElementTypesMustMatchMessage { - get { - return ResourceManager.GetString("LinearCollectionElementTypesMustMatchMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter. - /// - internal static string LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorDescription { - get { - return ResourceManager.GetString("LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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'. - /// - internal static string LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorMessage { - get { - return ResourceManager.GetString("LinearCollectionInCallerAllocatedBufferRequiresSpanConstructorMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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>'.. - /// - internal static string LinearCollectionInRequiresCollectionMethodsDescription { - get { - return ResourceManager.GetString("LinearCollectionInRequiresCollectionMethodsDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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>'. - /// - internal static string LinearCollectionInRequiresCollectionMethodsMessage { - get { - return ResourceManager.GetString("LinearCollectionInRequiresCollectionMethodsMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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. - /// - internal static string LinearCollectionInRequiresTwoParameterConstructorDescription { - get { - return ResourceManager.GetString("LinearCollectionInRequiresTwoParameterConstructorDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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. - /// - internal static string LinearCollectionInRequiresTwoParameterConstructorMessage { - get { - return ResourceManager.GetString("LinearCollectionInRequiresTwoParameterConstructorMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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>'.. - /// - internal static string LinearCollectionOutRequiresCollectionMethodsDescription { - get { - return ResourceManager.GetString("LinearCollectionOutRequiresCollectionMethodsDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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>'. - /// - internal static string LinearCollectionOutRequiresCollectionMethodsMessage { - get { - return ResourceManager.GetString("LinearCollectionOutRequiresCollectionMethodsMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'.. - /// - internal static string LinearCollectionOutRequiresIntConstructorDescription { - get { - return ResourceManager.GetString("LinearCollectionOutRequiresIntConstructorDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'.. - /// - internal static string LinearCollectionOutRequiresIntConstructorMessage { - get { - return ResourceManager.GetString("LinearCollectionOutRequiresIntConstructorMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum.. - /// - internal static string MarshallerDirectionMustBeValidDescription { - get { - return ResourceManager.GetString("MarshallerDirectionMustBeValidDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified custom marshaller direction for '{0}' is invalid. - /// - internal static string MarshallerDirectionMustBeValidMessage { - get { - return ResourceManager.GetString("MarshallerDirectionMustBeValidMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required.. - /// - internal static string MarshallerGetPinnableReferenceRequiresTwoStageMarshallingDescription { - get { - return ResourceManager.GetString("MarshallerGetPinnableReferenceRequiresTwoStageMarshallingDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported. - /// - internal static string MarshallerGetPinnableReferenceRequiresTwoStageMarshallingMessage { - get { - return ResourceManager.GetString("MarshallerGetPinnableReferenceRequiresTwoStageMarshallingMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum.. - /// - internal static string MarshallerKindMustBeValidDescription { - get { - return ResourceManager.GetString("MarshallerKindMustBeValidDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified custom marshaller kind for '{0}' is invalid. - /// - internal static string MarshallerKindMustBeValidMessage { - get { - return ResourceManager.GetString("MarshallerKindMustBeValidMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type. - /// - internal static string MarshallerTypeMustSpecifyManagedTypeDescription { - get { - return ResourceManager.GetString("MarshallerTypeMustSpecifyManagedTypeDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type. - /// - internal static string MarshallerTypeMustSpecifyManagedTypeMessage { - get { - return ResourceManager.GetString("MarshallerTypeMustSpecifyManagedTypeMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation.. - /// - internal static string NativeGenericTypeMustBeClosedOrMatchArityDescription { - get { - return ResourceManager.GetString("NativeGenericTypeMustBeClosedOrMatchArityDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type.. - /// - internal static string NativeGenericTypeMustBeClosedOrMatchArityMessage { - get { - return ResourceManager.GetString("NativeGenericTypeMustBeClosedOrMatchArityMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A native type must be blittable.. - /// - internal static string NativeTypeMustBeBlittableDescription { - get { - return ResourceManager.GetString("NativeTypeMustBeBlittableDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' for type '{1}' must be blittable. - /// - internal static string NativeTypeMustBeBlittableMessage { - get { - return ResourceManager.GetString("NativeTypeMustBeBlittableMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type.. - /// - internal static string NativeTypeMustBePointerSizedDescription { - get { - return ResourceManager.GetString("NativeTypeMustBePointerSizedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method. - /// - internal static string NativeTypeMustBePointerSizedMessage { - get { - return ResourceManager.GetString("NativeTypeMustBePointerSizedMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type.. - /// - internal static string NativeTypeMustHaveCustomTypeMarshallerAttributeDescription { - get { - return ResourceManager.GetString("NativeTypeMustHaveCustomTypeMarshallerAttributeDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. - /// - internal static string NativeTypeMustHaveCustomTypeMarshallerAttributeMessage { - get { - return ResourceManager.GetString("NativeTypeMustHaveCustomTypeMarshallerAttributeMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type.. - /// - internal static string OutRequiresToManagedDescription { - get { - return ResourceManager.GetString("OutRequiresToManagedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type. - /// - internal static string OutRequiresToManagedMessage { - get { - return ResourceManager.GetString("OutRequiresToManagedMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction.. - /// - internal static string OutTwoStageMarshallingRequiresFromNativeValueDescription { - get { - return ResourceManager.GetString("OutTwoStageMarshallingRequiresFromNativeValueDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter.. - /// - internal static string OutTwoStageMarshallingRequiresFromNativeValueMessage { - get { - return ResourceManager.GetString("OutTwoStageMarshallingRequiresFromNativeValueMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'Value' property must not be a 'ref' or 'readonly ref' property.. - /// - internal static string RefNativeValueUnsupportedDescription { - get { - return ResourceManager.GetString("RefNativeValueUnsupportedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property.. - /// - internal static string RefNativeValueUnsupportedMessage { - get { - return ResourceManager.GetString("RefNativeValueUnsupportedMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete.. - /// - internal static string SafeHandleByRefMustBeConcrete { - get { - return ResourceManager.GetString("SafeHandleByRefMustBeConcrete", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks.. - /// - internal static string TargetFrameworkNotSupportedDescription { - get { - return ResourceManager.GetString("TargetFrameworkNotSupportedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}.. - /// - internal static string TargetFrameworkNotSupportedMessage { - get { - return ResourceManager.GetString("TargetFrameworkNotSupportedMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Current target framework is not supported by source-generated P/Invokes. - /// - internal static string TargetFrameworkNotSupportedTitle { - get { - return ResourceManager.GetString("TargetFrameworkNotSupportedTitle", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature.. - /// - internal static string ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription { - get { - return ResourceManager.GetString("ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified.. - /// - internal static string ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage { - get { - return ResourceManager.GetString("ToNativeValueMethodProvidedShouldSpecifyTwoStageMarshallingFeatureMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same.. - /// - internal static string TwoStageMarshallingNativeTypesMustMatchDescription { - get { - return ResourceManager.GetString("TwoStageMarshallingNativeTypesMustMatchDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. - /// - internal static string TwoStageMarshallingNativeTypesMustMatchMessage { - get { - return ResourceManager.GetString("TwoStageMarshallingNativeTypesMustMatchMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type.. - /// - internal static string TypeNotSupportedDescription { - get { - return ResourceManager.GetString("TypeNotSupportedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'.. - /// - internal static string TypeNotSupportedMessageParameter { - get { - return ResourceManager.GetString("TypeNotSupportedMessageParameter", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to {0} The generated source will not handle marshalling of parameter '{1}'.. - /// - internal static string TypeNotSupportedMessageParameterWithDetails { - get { - return ResourceManager.GetString("TypeNotSupportedMessageParameterWithDetails", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'.. - /// - internal static string TypeNotSupportedMessageReturn { - get { - return ResourceManager.GetString("TypeNotSupportedMessageReturn", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to {0} The generated source will not handle marshalling of the return value of method '{1}'.. - /// - internal static string TypeNotSupportedMessageReturnWithDetails { - get { - return ResourceManager.GetString("TypeNotSupportedMessageReturnWithDetails", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Specified type is not supported by source-generated P/Invokes. - /// - internal static string TypeNotSupportedTitle { - get { - return ResourceManager.GetString("TypeNotSupportedTitle", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'UnmanagedResources' feature requires a 'void FreeNative()' method.. - /// - internal static string UnmanagedResourcesRequiresFreeNativeDescription { - get { - return ResourceManager.GetString("UnmanagedResourcesRequiresFreeNativeDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void'. - /// - internal static string UnmanagedResourcesRequiresFreeNativeMessage { - get { - return ResourceManager.GetString("UnmanagedResourcesRequiresFreeNativeMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters. - /// - internal static string ValueInCallerAllocatedBufferRequiresSpanConstructorDescription { - get { - return ResourceManager.GetString("ValueInCallerAllocatedBufferRequiresSpanConstructorDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters. - /// - internal static string ValueInCallerAllocatedBufferRequiresSpanConstructorMessage { - get { - return ResourceManager.GetString("ValueInCallerAllocatedBufferRequiresSpanConstructorMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter. - /// - internal static string ValueInRequiresOneParameterConstructorDescription { - get { - return ResourceManager.GetString("ValueInRequiresOneParameterConstructorDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to 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. - /// - internal static string ValueInRequiresOneParameterConstructorMessage { - get { - return ResourceManager.GetString("ValueInRequiresOneParameterConstructorMessage", resourceCulture); - } - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources.resx b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/Strings.resx similarity index 100% rename from src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources.resx rename to src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/Strings.resx diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.cs.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.cs.xlf new file mode 100644 index 0000000000000..661675de7c4f6 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.cs.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.de.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.de.xlf new file mode 100644 index 0000000000000..67dbab7b1568c --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.de.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.es.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.es.xlf new file mode 100644 index 0000000000000..b9e8c6e50e39e --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.es.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.fr.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.fr.xlf new file mode 100644 index 0000000000000..c61bde6083f17 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.fr.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.it.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.it.xlf new file mode 100644 index 0000000000000..62f494b1491fe --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.it.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ja.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ja.xlf new file mode 100644 index 0000000000000..62c9f095b3ad8 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ja.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ko.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ko.xlf new file mode 100644 index 0000000000000..adba6124afc55 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ko.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pl.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pl.xlf new file mode 100644 index 0000000000000..cc87c74accc3f --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pl.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pt-BR.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pt-BR.xlf new file mode 100644 index 0000000000000..a355eb968cb84 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.pt-BR.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ru.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ru.xlf new file mode 100644 index 0000000000000..9fed260cc5f49 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.ru.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.tr.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.tr.xlf new file mode 100644 index 0000000000000..6598f92445872 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.tr.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hans.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hans.xlf new file mode 100644 index 0000000000000..d84e6dc034bef --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hans.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hant.xlf b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hant.xlf new file mode 100644 index 0000000000000..835e269137a39 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Resources/xlf/Strings.zh-Hant.xlf @@ -0,0 +1,529 @@ + + + + + + Add missing custom type marshaller members + Add missing custom type marshaller members + + + + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + Add missing features to the 'CustomTypeMarshallerAttribute' attribute + + + + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + When a constructor taking a 'Span<byte>' is specified on the native type, the type must set the BufferSize field on the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to provide the size of the caller-allocated buffer. + + + + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + The native type '{0}' must set the 'BufferSize' field on the applied 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' to specify the size of the caller-allocated buffer because it has a constructor that takes a caller-allocated 'Span<byte>' + + + + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + A type that supports marshalling from managed to native using a caller-allocated buffer should also support marshalling from managed to native where using a caller-allocated buffer is impossible. + + + + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + Native type '{0}' has a constructor taking a caller-allocated buffer, but does not support marshalling in scenarios where using a caller-allocated buffer is impossible + + + + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + A marshaller type that provides a constructor taking a caller-allocated 'Span<byte>' should specify that it supports the 'CallerAllocatedBuffer' feature. + + + + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + The type '{0}' provides a constructor taking a caller-allocated 'Span<byte>' but does not specify that it supports the 'CallerAllocatedBuffer' feature. The constructor will not be used unless the feature is specified. + + + + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + The generated 'DllImportAttribute' will not have a value corresponding to '{0}'. + + + + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + '{0}' has no equivalent in 'DllImportAtttribute' and will not be forwarded + + + + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + Specified 'LibraryImportAttribute' arguments cannot be forwarded to 'DllImportAttribute' + + + + Source-generated P/Invokes will ignore any configuration that is not supported. + Source-generated P/Invokes will ignore any configuration that is not supported. + + + + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The '{0}' configuration is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + The specified marshalling configuration is not supported by source-generated P/Invokes. {0}. + + + + 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. + 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. + + + + 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. + 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. + + + + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + The specified value '{0}' for '{1}' is not supported by source-generated P/Invokes. If the specified configuration is required, use a regular `DllImport` instead. + + + + Specified configuration is not supported by source-generated P/Invokes. + Specified configuration is not supported by source-generated P/Invokes. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + Automatically converting a P/Invoke with 'PreserveSig' set to 'false' to a source-generated P/Invoke may produce invalid code + + + + Convert to 'LibraryImport' + Convert to 'LibraryImport' + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Mark the method '{0}' with 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + Use 'LibraryImportAttribute' instead of 'DllImportAttribute' to generate P/Invoke marshalling code at compile time + + + + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + Conversion to 'LibraryImport' may change behavior and compatibility. See {0} for more information. + {0} is a documentation link + + + Convert to 'LibraryImport' with '{0}' suffix + Convert to 'LibraryImport' with '{0}' suffix + + + + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + A native must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + The native type '{0}' must set the 'Direction' property on the 'CustomTypeMarshallerAttribute' to a value that sets at least one known flag value on the 'CustomTypeMarshallerDirection' enum + + + + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + The 'CustomTypeMarshallerAttribute' attribute must be semantically valid + + + + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + The 'CustomTypeMarshallerAttribute' on '{0}' is semantically invalid + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + A marshaller type that provides a 'FreeNative' method should specify that it supports the 'UnmanagedResources' feature. + + + + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FreeNative' method but does not specify that it supports the 'UnmanagedResources' feature. The method will not be used unless the feature is specified. + + + + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'FromNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'FromNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + The return type of 'GetPinnableReference' (after accounting for 'ref') must be blittable. + + + + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + The dereferenced type of the return type of the 'GetPinnableReference' method must be blittable + + + + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + A type that supports marshalling from managed to native by pinning should also support marshalling from managed to native where pinning is impossible. + + + + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + Type '{0}' has a 'GetPinnableReference' method but its native type does not support marshalling in scenarios where pinning is impossible + + + + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + The 'TwoStageMarshalling' feature requires a 'TNativeType ToNativeValue()' method for the 'In' direction. + + + + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + The marshaller type '{0}' supports marshalling in the 'In' direction with the 'TwoStageMarshalling' feature must provide a 'ToNativeValue' instance method that returns the native value + + + + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' is contained in a type '{1}' that is not marked 'partial'. P/Invoke source generation will ignore method '{0}'. + + + + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + Methods marked with 'LibraryImportAttribute' should be 'static', 'partial', and non-generic. P/Invoke source generation will ignore methods that are non-'static', non-'partial', or generic. + + + + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + Method '{0}' should be 'static', 'partial', and non-generic when marked with 'LibraryImportAttribute'. P/Invoke source generation will ignore method '{0}'. + + + + Invalid 'LibraryImportAttribute' usage + Invalid 'LibraryImportAttribute' usage + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' is invalid. + + + + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + The configuration of 'StringMarshalling' and 'StringMarshallingCustomType' on method '{0}' is invalid. {1} + {1} is a message containing additional details about what is not valid + + + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + 'StringMarshallingCustomType' must be specified when 'StringMarshalling' is set to 'StringMarshalling.Custom'. + + + + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + 'StringMarshalling' should be set to 'StringMarshalling.Custom' when 'StringMarshallingCustomType' is specified. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination'. + + + + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + The element type of the 'ReadOnlySpan' returned by 'GetManagedValuesSource' must be the same as the element type returned by 'GetManagedValuesDestination' + + + + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + A 'LinearCollection'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a three-parameter constructor taking the managed type as the first parameter, a 'Span<byte>' as the second parameter, and the native size of the element as the third parameter + + + + 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' + 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' + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + 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 + 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 + + + + 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 + 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 + + + + 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>'. + 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>'. + + + + 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>' + 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>' + + + + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + A 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a constructor that takes the size of the native element as an 'int'. + + + + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + The type '{0}' specifies that it supports marshalling in the 'Out' direction, but it does not provide a constructor that takes the size of the native element as an 'int'. + + + + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + The specified marshaller direction must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerDirection' enum. + + + + The specified custom marshaller direction for '{0}' is invalid + The specified custom marshaller direction for '{0}' is invalid + + + + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + The use cases for 'GetPinnableReference' are not applicable in any scenarios where 'TwoStageMarshalling' is not also required. + + + + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + The 'GetPinnableReference' method cannot be provided on the native type '{0}' unless the 'TwoStageMarshalling' feature is also supported + + + + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + The specified marshaller kind must be a valid value of the 'System.Runtime.InteropServices.CustomMarshallerKind' enum. + + + + The specified custom marshaller kind for '{0}' is invalid + The specified custom marshaller kind for '{0}' is invalid + + + + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + A type with a 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' must specify a managed type + + + + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + The type '{0}' does not specify a managed type in the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' applied to the type + + + + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + The native type '{0}' must be a closed generic or have the same number of generic parameters as the managed type so the emitted code can use a specific instantiation. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + A native type must be blittable. + A native type must be blittable. + + + + The native type '{0}' for type '{1}' must be blittable + The native type '{0}' for type '{1}' must be blittable + + + + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + The native type must be pointer sized so the pinned result of 'GetPinnableReference' can be cast to the native type. + + + + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + The native type '{0}' must be pointer sized because the managed type '{1}' has a 'GetPinnableReference' method + + + + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + A native type for a given type must have the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type. + + + + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + The native type for the type '{0}' must be a type with the 'System.Runtime.InteropServices.CustomTypeMarshallerAttribute' that specifies this type as the managed type + + + + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + A 'Value' or 'LinearCollection'-kind native type that supports marshalling in the 'Out' direction must provide a 'ToManaged' method that returns the managed type. + + + + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + The type '{0}' specifies it supports marshalling in the 'Out' direction, but it does not provide a 'ToManaged' method that returns the managed type + + + + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + The 'TwoStageMarshalling' feature requires a 'void FromNativeValue(TNativeType value)' method for the 'Out' direction. + + + + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + The marshaller type '{0}' supports marshalling in the 'Out' direction with the 'TwoStageMarshalling' feature, but it does not provide a 'FromNativeValue' instance method that returns 'void' and takes one parameter. + + + + The 'Value' property must not be a 'ref' or 'readonly ref' property. + The 'Value' property must not be a 'ref' or 'readonly ref' property. + + + + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + P/Invoke source generation is not supported on unknown target framework v{0}. The generated source will not be compatible with other frameworks. + {0} is a version number + + + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + 'LibraryImportAttribute' cannot be used for source-generated P/Invokes on an unknown target framework v{0}. + {0} is a version number + + + Current target framework is not supported by source-generated P/Invokes + Current target framework is not supported by source-generated P/Invokes + + + + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + A marshaller type that provides a 'ToNativeValue' method should specify that it supports the 'TwoStageMarshalling' feature. + + + + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + The type '{0}' provides a 'ToNativeValue' method but does not specify that it supports the 'TwoStageMarshalling' feature. The method will not be used unless the feature is specified. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same. + + + + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + The return type of 'ToNativeValue' and the parameter type of 'FromNativeValue' must be the same + + + + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + For types that are not supported by source-generated P/Invokes, the resulting P/Invoke will rely on the underlying runtime to marshal the specified type. + + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of parameter '{1}'. + + + + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} The generated source will not handle marshalling of parameter '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the parameter + + + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + The type '{0}' is not supported by source-generated P/Invokes. The generated source will not handle marshalling of the return value of method '{1}'. + + + + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} The generated source will not handle marshalling of the return value of method '{1}'. + {0} is a message containing additional details about what is not supported +{1} is the name of the method + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + The 'UnmanagedResources' feature requires a 'void FreeNative()' method. + + + + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + The marshaller type '{0}' supports marshalling with the 'UnmanagedResources' feature, but it does not provide a parameterless 'FreeNative' instance method that returns 'void' + + + + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + A 'Value'-kind native type that supports the 'CallerAllocatedBuffer' feature must provide a two-parameter constructor taking the managed type and a 'Span<byte>' as parameters + + + + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + The type '{0}' specifies that it supports 'In' marshalling with the 'CallerAllocatedBuffer' feature for '{1}' but does not provide a one-parameter constructor that takes a '{1}' and 'Span<byte>' as parameters + + + + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + A 'Value'-kind native type must provide a one-parameter constructor taking the managed type as a parameter + + + + 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 + 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 + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorFactory.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorFactory.cs index f3aac5de6a729..a2e9a5d4f4a4d 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorFactory.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorFactory.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System; using System.Collections.Generic; using System.Runtime.InteropServices; using Microsoft.CodeAnalysis; @@ -54,7 +55,7 @@ public IMarshallingGenerator Create(TypePositionInfo info, StubCodeContext conte UnmanagedBlittableMarshallingInfo or NativeMarshallingAttributeInfo when !Options.RuntimeMarshallingDisabled => throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.RuntimeMarshallingMustBeDisabled + NotSupportedDetails = SR.RuntimeMarshallingMustBeDisabled }, GeneratedNativeMarshallingAttributeInfo => s_forwarder, MissingSupportMarshallingInfo => s_forwarder, @@ -73,7 +74,7 @@ private static ExpressionSyntax GetNumElementsExpressionFromMarshallingInfo(Type CountElementCountInfo(TypePositionInfo elementInfo) => CheckedExpression(SyntaxKind.CheckedExpression, GetExpressionForParam(elementInfo)), _ => throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.ArraySizeMustBeSpecified + NotSupportedDetails = SR.ArraySizeMustBeSpecified }, }; @@ -103,7 +104,7 @@ ExpressionSyntax GetExpressionForParam(TypePositionInfo paramInfo) { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.CollectionSizeParamTypeMustBeIntegral + NotSupportedDetails = SR.CollectionSizeParamTypeMustBeIntegral }; } } @@ -112,7 +113,7 @@ ExpressionSyntax GetExpressionForParam(TypePositionInfo paramInfo) { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.CollectionSizeParamTypeMustBeIntegral + NotSupportedDetails = SR.CollectionSizeParamTypeMustBeIntegral }; } @@ -202,7 +203,7 @@ private void ValidateCustomNativeTypeMarshallingSupported(TypePositionInfo info, { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = string.Format(Resources.CustomTypeMarshallingNativeToManagedUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) + NotSupportedDetails = string.Format(SR.CustomTypeMarshallingNativeToManagedUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) }; } // The marshalling method for this type doesn't support marshalling from managed to native by value, @@ -215,7 +216,7 @@ private void ValidateCustomNativeTypeMarshallingSupported(TypePositionInfo info, { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = string.Format(Resources.CustomTypeMarshallingManagedToNativeUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) + NotSupportedDetails = string.Format(SR.CustomTypeMarshallingManagedToNativeUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) }; } // The marshalling method for this type doesn't support marshalling from managed to native by reference, @@ -227,7 +228,7 @@ private void ValidateCustomNativeTypeMarshallingSupported(TypePositionInfo info, { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = string.Format(Resources.CustomTypeMarshallingManagedToNativeUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) + NotSupportedDetails = string.Format(SR.CustomTypeMarshallingManagedToNativeUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) }; } // The marshalling method for this type doesn't support marshalling from managed to native by reference, @@ -239,7 +240,7 @@ private void ValidateCustomNativeTypeMarshallingSupported(TypePositionInfo info, { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = string.Format(Resources.CustomTypeMarshallingManagedToNativeUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) + NotSupportedDetails = string.Format(SR.CustomTypeMarshallingManagedToNativeUnsupported, marshalInfo.NativeMarshallingType.FullTypeName) }; } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs index 169911c3c92c3..c5112e2ed49c3 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs @@ -36,14 +36,14 @@ private static IMarshallingGenerator ValidateByValueMarshalKind(TypePositionInfo { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.InOutAttributeByRefNotSupported + NotSupportedDetails = SR.InOutAttributeByRefNotSupported }; } else if (info.ByValueContentsMarshalKind == ByValueContentsMarshalKind.In) { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.InAttributeNotSupportedWithoutOut + NotSupportedDetails = SR.InAttributeNotSupportedWithoutOut }; } else if (info.ByValueContentsMarshalKind != ByValueContentsMarshalKind.Default @@ -51,7 +51,7 @@ private static IMarshallingGenerator ValidateByValueMarshalKind(TypePositionInfo { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.InOutAttributeMarshalerNotSupported + NotSupportedDetails = SR.InOutAttributeMarshalerNotSupported }; } return generator; diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorFactory.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorFactory.cs index 4355feac8a193..9e0db896873d0 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorFactory.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorFactory.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System; using System.Runtime.InteropServices; using Microsoft.CodeAnalysis; @@ -78,7 +79,7 @@ public IMarshallingGenerator Create( case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Boolean }, MarshallingAttributeInfo: NoMarshallingInfo }: throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.MarshallingBoolAsUndefinedNotSupported + NotSupportedDetails = SR.MarshallingBoolAsUndefinedNotSupported }; case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Boolean }, MarshallingAttributeInfo: MarshalAsInfo(UnmanagedType.I1 or UnmanagedType.U1, _) }: return s_byteBool; @@ -99,7 +100,7 @@ public IMarshallingGenerator Create( { throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.SafeHandleByRefMustBeConcrete + NotSupportedDetails = SR.SafeHandleByRefMustBeConcrete }; } return s_safeHandle; @@ -126,7 +127,7 @@ private IMarshallingGenerator CreateCharMarshaller(TypePositionInfo info, StubCo // [Compat] Require explicit marshalling information. throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.MarshallingStringOrCharAsUndefinedNotSupported + NotSupportedDetails = SR.MarshallingStringOrCharAsUndefinedNotSupported }; } @@ -149,7 +150,7 @@ private IMarshallingGenerator CreateCharMarshaller(TypePositionInfo info, StubCo case CharEncoding.Ansi: throw new MarshallingNotSupportedException(info, context) // [Compat] ANSI is not supported for char { - NotSupportedDetails = string.Format(Resources.MarshallingCharAsSpecifiedCharSetNotSupported, CharSet.Ansi) + NotSupportedDetails = string.Format(SR.MarshallingCharAsSpecifiedCharSetNotSupported, CharSet.Ansi) }; } } @@ -165,7 +166,7 @@ private IMarshallingGenerator CreateStringMarshaller(TypePositionInfo info, Stub // [Compat] Require explicit marshalling information. throw new MarshallingNotSupportedException(info, context) { - NotSupportedDetails = Resources.MarshallingStringOrCharAsUndefinedNotSupported + NotSupportedDetails = SR.MarshallingStringOrCharAsUndefinedNotSupported }; } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs index dc1a04c698110..993334ac98896 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs @@ -191,7 +191,7 @@ public static IEnumerable GetTopologicallySortedElements( // If we have edges left, then we have a cycle. if (edgeMap.AnyEdges) { - throw new InvalidOperationException(Resources.GraphHasCycles); + throw new InvalidOperationException(SR.GraphHasCycles); } // If we make it here, we have a topologically sorted list. diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs index 86bab61b2200c..e78ae6d0f95d5 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs @@ -236,7 +236,7 @@ private MarshallingInfo ParseMarshallingInfo( { if (marshallingAttributesByIndirectionDepth.ContainsKey(indirectionLevel)) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(attribute, nameof(Resources.DuplicateMarshallingInfo), indirectionLevel.ToString()); + _diagnostics.ReportInvalidMarshallingAttributeInfo(attribute, nameof(SR.DuplicateMarshallingInfo), indirectionLevel.ToString()); return NoMarshallingInfo.Instance; } marshallingAttributesByIndirectionDepth.Add(indirectionLevel, attribute); @@ -255,7 +255,7 @@ private MarshallingInfo ParseMarshallingInfo( { _diagnostics.ReportInvalidMarshallingAttributeInfo( marshallingAttributesByIndirectionDepth[maxIndirectionLevelDataProvided], - nameof(Resources.ExtraneousMarshallingInfo), + nameof(SR.ExtraneousMarshallingInfo), maxIndirectionLevelDataProvided.ToString(), maxIndirectionDepthUsed.ToString()); } @@ -286,7 +286,7 @@ private MarshallingInfo GetMarshallingInfo( { if (parsedCountInfo != NoCountInfo.Instance) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(useSiteAttribute, nameof(Resources.DuplicateCountInfo)); + _diagnostics.ReportInvalidMarshallingAttributeInfo(useSiteAttribute, nameof(SR.DuplicateCountInfo)); return NoMarshallingInfo.Instance; } parsedCountInfo = CreateCountInfo(useSiteAttribute, inspectedElements); @@ -371,7 +371,7 @@ private CountInfo CreateCountInfo(AttributeData marshalUsingData, ImmutableHashS if (constSize is not null && elementName is not null) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(marshalUsingData, nameof(Resources.ConstantAndElementCountInfoDisallowed)); + _diagnostics.ReportInvalidMarshallingAttributeInfo(marshalUsingData, nameof(SR.ConstantAndElementCountInfoDisallowed)); } else if (constSize is not null) { @@ -398,7 +398,7 @@ private CountInfo CreateCountInfo(AttributeData marshalUsingData, ImmutableHashS // This ensures that we've unwound the whole cycle so when we return NoCountInfo.Instance, there will be no cycles in the count info. catch (CyclicalCountElementInfoException ex) when (ex.StartOfCycle == elementName) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(marshalUsingData, nameof(Resources.CyclicalCountInfo), elementName); + _diagnostics.ReportInvalidMarshallingAttributeInfo(marshalUsingData, nameof(SR.CyclicalCountInfo), elementName); return NoCountInfo.Instance; } } @@ -430,7 +430,7 @@ private CountInfo CreateCountInfo(AttributeData marshalUsingData, ImmutableHashS // This ensures that we've unwound the whole cycle so when we return, there will be no cycles in the count info. catch (CyclicalCountElementInfoException ex) when (ex.StartOfCycle == param.Name) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(Resources.CyclicalCountInfo), param.Name); + _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(SR.CyclicalCountInfo), param.Name); return SizeAndParamIndexInfo.UnspecifiedParam; } } @@ -609,14 +609,14 @@ private MarshallingInfo CreateNativeMarshallingInfo( { if (isMarshalUsingAttribute) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(Resources.NativeGenericTypeMustBeClosedOrMatchArityMessage), nativeType.ToDisplayString()); + _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(SR.NativeGenericTypeMustBeClosedOrMatchArityMessage), nativeType.ToDisplayString()); return NoMarshallingInfo.Instance; } else if (type is INamedTypeSymbol namedType) { if (namedType.Arity != nativeType.Arity) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(Resources.NativeGenericTypeMustBeClosedOrMatchArityMessage), nativeType.ToDisplayString()); + _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(SR.NativeGenericTypeMustBeClosedOrMatchArityMessage), nativeType.ToDisplayString()); return NoMarshallingInfo.Instance; } else @@ -626,7 +626,7 @@ private MarshallingInfo CreateNativeMarshallingInfo( } else { - _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(Resources.NativeGenericTypeMustBeClosedOrMatchArityMessage), nativeType.ToDisplayString()); + _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(SR.NativeGenericTypeMustBeClosedOrMatchArityMessage), nativeType.ToDisplayString()); return NoMarshallingInfo.Instance; } } @@ -655,7 +655,7 @@ private MarshallingInfo CreateNativeMarshallingInfo( { if (!ManualTypeMarshallingHelper.TryGetElementTypeFromLinearCollectionMarshaller(nativeType, readOnlySpanOfT, out ITypeSymbol elementType)) { - _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(Resources.CollectionNativeTypeMustHaveRequiredShapeMessage), nativeType.ToDisplayString()); + _diagnostics.ReportInvalidMarshallingAttributeInfo(attrData, nameof(SR.CollectionNativeTypeMustHaveRequiredShapeMessage), nativeType.ToDisplayString()); return NoMarshallingInfo.Instance; } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj index 8c9dbccb9f1d8..7d7e5fe7b2254 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj @@ -9,10 +9,6 @@ - - - - - diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources.Designer.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources.Designer.cs deleted file mode 100644 index 626e683b776e9..0000000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources.Designer.cs +++ /dev/null @@ -1,387 +0,0 @@ -//------------------------------------------------------------------------------ -// -// This code was generated by a tool. -// Runtime Version:4.0.30319.42000 -// -// Changes to this file may cause incorrect behavior and will be lost if -// the code is regenerated. -// -//------------------------------------------------------------------------------ - -namespace Microsoft.Interop { - using System; - - - /// - /// A strongly-typed resource class, for looking up localized strings, etc. - /// - // This class was auto-generated by the StronglyTypedResourceBuilder - // class via a tool like ResGen or Visual Studio. - // To add or remove a member, edit your .ResX file then rerun ResGen - // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] - [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] - [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] - internal class Resources { - - private static global::System.Resources.ResourceManager resourceMan; - - private static global::System.Globalization.CultureInfo resourceCulture; - - [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] - internal Resources() { - } - - /// - /// Returns the cached ResourceManager instance used by this class. - /// - [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Resources.ResourceManager ResourceManager { - get { - if (object.ReferenceEquals(resourceMan, null)) { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Interop.Resources", typeof(Resources).Assembly); - resourceMan = temp; - } - return resourceMan; - } - } - - /// - /// Overrides the current thread's CurrentUICulture property for all - /// resource lookups using this strongly typed resource class. - /// - [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - internal static global::System.Globalization.CultureInfo Culture { - get { - return resourceCulture; - } - set { - resourceCulture = value; - } - } - - /// - /// Looks up a localized string similar to Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'.. - /// - internal static string ArraySizeMustBeSpecified { - get { - return ResourceManager.GetString("ArraySizeMustBeSpecified", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range.. - /// - internal static string ArraySizeParamIndexOutOfRange { - get { - return ResourceManager.GetString("ArraySizeParamIndexOutOfRange", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive.. - /// - internal static string CannotHaveMultipleMarshallingAttributesDescription { - get { - return ResourceManager.GetString("CannotHaveMultipleMarshallingAttributesDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes.. - /// - internal static string CannotHaveMultipleMarshallingAttributesMessage { - get { - return ResourceManager.GetString("CannotHaveMultipleMarshallingAttributesMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type.. - /// - internal static string CollectionNativeTypeMustHaveRequiredShapeDescription { - get { - return ResourceManager.GetString("CollectionNativeTypeMustHaveRequiredShapeDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>'. - /// - internal static string CollectionNativeTypeMustHaveRequiredShapeMessage { - get { - return ResourceManager.GetString("CollectionNativeTypeMustHaveRequiredShapeMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element.. - /// - internal static string CollectionSizeParamTypeMustBeIntegral { - get { - return ResourceManager.GetString("CollectionSizeParamTypeMustBeIntegral", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth'. - /// - internal static string ConstantAndElementCountInfoDisallowed { - get { - return ResourceManager.GetString("ConstantAndElementCountInfoDisallowed", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it.. - /// - internal static string CustomTypeMarshallingManagedToNativeUnsupported { - get { - return ResourceManager.GetString("CustomTypeMarshallingManagedToNativeUnsupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it.. - /// - internal static string CustomTypeMarshallingNativeToManagedUnsupported { - get { - return ResourceManager.GetString("CustomTypeMarshallingNativeToManagedUnsupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to This element cannot depend on '{0}' for collection size information without creating a dependency cycle. - /// - internal static string CyclicalCountInfo { - get { - return ResourceManager.GetString("CyclicalCountInfo", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Count information for a given element at a given indirection level can only be specified once. - /// - internal static string DuplicateCountInfo { - get { - return ResourceManager.GetString("DuplicateCountInfo", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0}. - /// - internal static string DuplicateMarshallingInfo { - get { - return ResourceManager.GetString("DuplicateMarshallingInfo", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection. - /// - internal static string ExtraneousMarshallingInfo { - get { - return ResourceManager.GetString("ExtraneousMarshallingInfo", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The provided graph has cycles and cannot be topologically sorted.. - /// - internal static string GraphHasCycles { - get { - return ResourceManager.GetString("GraphHasCycles", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior.. - /// - internal static string InAttributeNotSupportedWithoutOut { - get { - return ResourceManager.GetString("InAttributeNotSupportedWithoutOut", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead.. - /// - internal static string InOutAttributeByRefNotSupported { - get { - return ResourceManager.GetString("InOutAttributeByRefNotSupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter.. - /// - internal static string InOutAttributeMarshalerNotSupported { - get { - return ResourceManager.GetString("InOutAttributeMarshalerNotSupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'.. - /// - internal static string MarshallingBoolAsUndefinedNotSupported { - get { - return ResourceManager.GetString("MarshallingBoolAsUndefinedNotSupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke.. - /// - internal static string MarshallingCharAsSpecifiedCharSetNotSupported { - get { - return ResourceManager.GetString("MarshallingCharAsSpecifiedCharSetNotSupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'.. - /// - internal static string MarshallingStringOrCharAsUndefinedNotSupported { - get { - return ResourceManager.GetString("MarshallingStringOrCharAsUndefinedNotSupported", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type.. - /// - internal static string NativeGenericTypeMustBeClosedOrMatchArityMessage { - get { - return ResourceManager.GetString("NativeGenericTypeMustBeClosedOrMatchArityMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type must have at least one of the two marshalling methods to enable marshalling the managed type.. - /// - internal static string NativeTypeMustHaveRequiredShapeDescription { - get { - return ResourceManager.GetString("NativeTypeMustHaveRequiredShapeDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type '{0}' must be a value type and have a constructor that takes one parameter of type '{1}' or a parameterless instance method named 'ToManaged' that returns '{1}'. - /// - internal static string NativeTypeMustHaveRequiredShapeMessage { - get { - return ResourceManager.GetString("NativeTypeMustHaveRequiredShapeMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The '[Out]' attribute is only supported on array parameters.. - /// - internal static string OutByValueNotSupportedDescription { - get { - return ResourceManager.GetString("OutByValueNotSupportedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The '[Out]' attribute is not supported on the '{0}' parameter.. - /// - internal static string OutByValueNotSupportedMessage { - get { - return ResourceManager.GetString("OutByValueNotSupportedMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'Value' property must not be a 'ref' or 'readonly ref' property.. - /// - internal static string RefNativeValueUnsupportedDescription { - get { - return ResourceManager.GetString("RefNativeValueUnsupportedDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'Value' property on the native type '{0}' must not be a 'ref' or 'readonly ref' property.. - /// - internal static string RefNativeValueUnsupportedMessage { - get { - return ResourceManager.GetString("RefNativeValueUnsupportedMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type.. - /// - internal static string RuntimeMarshallingMustBeDisabled { - get { - return ResourceManager.GetString("RuntimeMarshallingMustBeDisabled", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete.. - /// - internal static string SafeHandleByRefMustBeConcrete { - get { - return ResourceManager.GetString("SafeHandleByRefMustBeConcrete", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Specified type is not supported by source-generated P/Invokes. - /// - internal static string TypeNotSupportedTitle { - get { - return ResourceManager.GetString("TypeNotSupportedTitle", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to Marshalling a value between managed and native with a native type with a 'Value' property requires extra state, which is not supported in this context.. - /// - internal static string ValuePropertyMarshallingRequiresAdditionalState { - get { - return ResourceManager.GetString("ValuePropertyMarshallingRequiresAdditionalState", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type's 'Value' property must have a getter to support marshalling from managed to native.. - /// - internal static string ValuePropertyMustHaveGetterDescription { - get { - return ResourceManager.GetString("ValuePropertyMustHaveGetterDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'Value' property on the native type '{0}' must have a getter. - /// - internal static string ValuePropertyMustHaveGetterMessage { - get { - return ResourceManager.GetString("ValuePropertyMustHaveGetterMessage", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The native type's 'Value' property must have a setter to support marshalling from native to managed.. - /// - internal static string ValuePropertyMustHaveSetterDescription { - get { - return ResourceManager.GetString("ValuePropertyMustHaveSetterDescription", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to The 'Value' property on the native type '{0}' must have a setter. - /// - internal static string ValuePropertyMustHaveSetterMessage { - get { - return ResourceManager.GetString("ValuePropertyMustHaveSetterMessage", resourceCulture); - } - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources.resx b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/Strings.resx similarity index 100% rename from src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources.resx rename to src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/Strings.resx diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.cs.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.cs.xlf new file mode 100644 index 0000000000000..a61cc27f8112a --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.cs.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.de.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.de.xlf new file mode 100644 index 0000000000000..e2e8d52edaeb0 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.de.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.es.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.es.xlf new file mode 100644 index 0000000000000..13798c5a101e3 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.es.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.fr.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.fr.xlf new file mode 100644 index 0000000000000..44b14b340fbd5 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.fr.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.it.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.it.xlf new file mode 100644 index 0000000000000..3464fd955578e --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.it.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ja.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ja.xlf new file mode 100644 index 0000000000000..a955b30085949 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ja.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ko.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ko.xlf new file mode 100644 index 0000000000000..db30b860d51db --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ko.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pl.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pl.xlf new file mode 100644 index 0000000000000..fdb876b0ff8a2 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pl.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pt-BR.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pt-BR.xlf new file mode 100644 index 0000000000000..7b8bcf88be047 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.pt-BR.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ru.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ru.xlf new file mode 100644 index 0000000000000..e43fc3c65fb7d --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.ru.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.tr.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.tr.xlf new file mode 100644 index 0000000000000..423b980c25875 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.tr.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hans.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hans.xlf new file mode 100644 index 0000000000000..47cbe134d4499 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hans.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hant.xlf b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hant.xlf new file mode 100644 index 0000000000000..62c4bcd5172b3 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Resources/xlf/Strings.zh-Hant.xlf @@ -0,0 +1,142 @@ + + + + + + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + Marshalling an array from unmanaged to managed requires either the 'SizeParamIndex' or 'SizeConst' fields to be set on a 'MarshalAsAttribute' or the 'ConstantElementCount' or 'CountElementName' properties to be set on a 'MarshalUsingAttribute'. + + + + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + The 'SizeParamIndex' value in the 'MarshalAsAttribute' is out of range. + + + + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + The 'BlittableTypeAttribute' and 'NativeMarshallingAttribute' attributes are mutually exclusive. + + + + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + Type '{0}' is marked with 'BlittableTypeAttribute' and 'NativeMarshallingAttribute'. A type can only have one of these two attributes. + + + + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + A native type with the 'GenericContiguousCollectionMarshallerAttribute' must have at least one of the two marshalling methods as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' to enable marshalling the managed type. + + + + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + The native type '{0}' must be a value type and have a constructor that takes two parameters, one of type '{1}' and an 'int', or have a parameterless instance method named 'ToManaged' that returns '{1}' as well as a 'ManagedValues' property of type 'Span<T>' for some 'T' and a 'NativeValueStorage' property of type 'Span<byte>' + + + + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + The specified collection size parameter for an collection must be an integer type. If the size information is applied to a nested collection, the size parameter must be a collection of one less level of nesting with an integral element. + + + + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + Only one of 'ConstantElementCount' or 'ElementCountInfo' may be used in a 'MarshalUsingAttribute' for a given 'ElementIndirectionDepth' + + + + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from managed to native, but the native type '{0}' does not support it. + + + + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + The specified parameter needs to be marshalled from native to managed, but the native type '{0}' does not support it. + + + + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + This element cannot depend on '{0}' for collection size information without creating a dependency cycle + + + + Count information for a given element at a given indirection level can only be specified once + Count information for a given element at a given indirection level can only be specified once + + + + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + Multiple marshalling attributes per element per indirection level is unsupported, but duplicate information was provided for indirection level {0} + + + + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + Marshalling info was specified for 'ElementIndirectionDepth' {0}, but marshalling info was only needed for {1} level(s) of indirection + + + + The provided graph has cycles and cannot be topologically sorted. + The provided graph has cycles and cannot be topologically sorted. + + + + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + The '[In]' attribute is not supported unless the '[Out]' attribute is also used. The behavior of the '[In]' attribute without the '[Out]' attribute is the same as the default behavior. + + + + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + The '[In]' and '[Out]' attributes are unsupported on parameters passed by reference. Use the 'in', 'ref', or 'out' keywords instead. + + + + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + The provided '[In]' and '[Out]' attributes on this parameter are unsupported on this parameter. + + + + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + Marshalling bool without explicit marshalling information is not supported. Specify either 'MarshalUsingAttribute' or 'MarshalAsAttribute'. + + + + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + Marshalling char with 'CharSet.{0}' is not supported. Instead, manually convert the char type to the desired byte representation and pass to the source-generated P/Invoke. + + + + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + Marshalling string or char without explicit marshalling information is not supported. Specify either 'LibraryImportAttribute.CharSet' or 'MarshalAsAttribute'. + + + + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + The native type '{0}' for managed type '{1}' must be a closed generic type or have the same arity as the managed type. + + + + The '[Out]' attribute is only supported on array parameters. + The '[Out]' attribute is only supported on array parameters. + + + + The '[Out]' attribute is not supported on the '{0}' parameter. + The '[Out]' attribute is not supported on the '{0}' parameter. + + + + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + Runtime marshalling must be disabled in this project by applying the 'System.Runtime.InteropServices.DisableRuntimeMarshallingAttribute' to the assembly to enable marshalling this type. + + + + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + An abstract type derived from 'SafeHandle' cannot be marshalled by reference. The provided type must be concrete. + + + + Specified type is not supported by source-generated P/Invokes + Specified type is not supported by source-generated P/Invokes + + + + + \ No newline at end of file From bb9c135341d10e65dad7939dd9a63dfe40317b30 Mon Sep 17 00:00:00 2001 From: Elinor Fung Date: Thu, 24 Mar 2022 12:50:59 -0700 Subject: [PATCH 2/2] Update src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj Co-authored-by: Jeremy Koritzinsky --- .../gen/LibraryImportGenerator/LibraryImportGenerator.csproj | 1 - 1 file changed, 1 deletion(-) diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj index 19c0adfe5ae8c..7e7e4c28bd6e2 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj @@ -12,7 +12,6 @@ RS2008;$(NoWarn) - cs