diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.App.Analyzers.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.App.Analyzers.cs new file mode 100644 index 00000000000..dcd9c4cdbbb --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.App.Analyzers.cs @@ -0,0 +1,38 @@ +// This file contains auto-generated code. +// Generated from `Microsoft.AspNetCore.App.Analyzers, Version=7.0.10.0, Culture=neutral, PublicKeyToken=adb9793829ddae60`. +namespace Microsoft +{ + namespace AspNetCore + { + namespace Analyzers + { + namespace RenderTreeBuilder + { + public class RenderTreeBuilderAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public RenderTreeBuilderAnalyzer() => throw null; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + } + namespace RouteHandlers + { + public class RouteHandlerAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public RouteHandlerAnalyzer() => throw null; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + } + namespace WebApplicationBuilder + { + public sealed class WebApplicationBuilderAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public WebApplicationBuilderAnalyzer() => throw null; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + } + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.App.CodeFixes.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.App.CodeFixes.cs new file mode 100644 index 00000000000..9e7b879595d --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.App.CodeFixes.cs @@ -0,0 +1,37 @@ +// This file contains auto-generated code. +// Generated from `Microsoft.AspNetCore.App.CodeFixes, Version=7.0.10.0, Culture=neutral, PublicKeyToken=adb9793829ddae60`. +namespace Microsoft +{ + namespace AspNetCore + { + namespace Analyzers + { + namespace RouteHandlers + { + namespace Fixers + { + public class DetectMismatchedParameterOptionalityFixer : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider + { + public DetectMismatchedParameterOptionalityFixer() => throw null; + public override System.Collections.Immutable.ImmutableArray FixableDiagnosticIds { get => throw null; } + public override sealed Microsoft.CodeAnalysis.CodeFixes.FixAllProvider GetFixAllProvider() => throw null; + public override sealed System.Threading.Tasks.Task RegisterCodeFixesAsync(Microsoft.CodeAnalysis.CodeFixes.CodeFixContext context) => throw null; + } + } + } + namespace WebApplicationBuilder + { + namespace Fixers + { + public sealed class WebApplicationBuilderFixer : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider + { + public WebApplicationBuilderFixer() => throw null; + public override System.Collections.Immutable.ImmutableArray FixableDiagnosticIds { get => throw null; } + public override sealed Microsoft.CodeAnalysis.CodeFixes.FixAllProvider GetFixAllProvider() => throw null; + public override sealed System.Threading.Tasks.Task RegisterCodeFixesAsync(Microsoft.CodeAnalysis.CodeFixes.CodeFixContext context) => throw null; + } + } + } + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.Components.Analyzers.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.Components.Analyzers.cs new file mode 100644 index 00000000000..792ff28a867 --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.AspNetCore.Components.Analyzers.cs @@ -0,0 +1,45 @@ +// This file contains auto-generated code. +// Generated from `Microsoft.AspNetCore.Components.Analyzers, Version=7.0.10.0, Culture=neutral, PublicKeyToken=adb9793829ddae60`. +namespace Microsoft +{ + namespace AspNetCore + { + namespace Components + { + namespace Analyzers + { + public sealed class ComponentParameterAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public ComponentParameterAnalyzer() => throw null; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + public class ComponentParametersShouldBePublicCodeFixProvider : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider + { + public ComponentParametersShouldBePublicCodeFixProvider() => throw null; + public override System.Collections.Immutable.ImmutableArray FixableDiagnosticIds { get => throw null; } + public override sealed Microsoft.CodeAnalysis.CodeFixes.FixAllProvider GetFixAllProvider() => throw null; + public override sealed System.Threading.Tasks.Task RegisterCodeFixesAsync(Microsoft.CodeAnalysis.CodeFixes.CodeFixContext context) => throw null; + } + public class ComponentParameterUsageAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public ComponentParameterUsageAnalyzer() => throw null; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + } + } + } + namespace Extensions + { + namespace Internal + { + public class ComponentInternalUsageDiagnosticAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public ComponentInternalUsageDiagnosticAnalyzer() => throw null; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.Extensions.Logging.Generators.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.Extensions.Logging.Generators.cs new file mode 100644 index 00000000000..eeaea7a61b9 --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.AspNetCore.App/Microsoft.Extensions.Logging.Generators.cs @@ -0,0 +1,44 @@ +// This file contains auto-generated code. +// Generated from `Microsoft.Extensions.Logging.Generators, Version=7.0.8.36312, Culture=neutral, PublicKeyToken=adb9793829ddae60`. +namespace Microsoft +{ + namespace Extensions + { + namespace Logging + { + namespace Generators + { + public static class DiagnosticDescriptors + { + public static Microsoft.CodeAnalysis.DiagnosticDescriptor ArgumentHasNoCorrespondingTemplate { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor GeneratingForMax6Arguments { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor InconsistentTemplateCasing { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidLoggingMethodName { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidLoggingMethodParameterName { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor LoggingMethodHasBody { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor LoggingMethodIsGeneric { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor LoggingMethodMustBePartial { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor LoggingMethodMustReturnVoid { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor LoggingMethodShouldBeStatic { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor MalformedFormatStrings { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor MissingLoggerArgument { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor MissingLoggerField { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor MissingLogLevel { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor MissingRequiredType { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor MultipleLoggerFields { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor RedundantQualifierInMessage { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor ShouldntMentionExceptionInMessage { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor ShouldntMentionLoggerInMessage { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor ShouldntMentionLogLevelInMessage { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor ShouldntReuseEventIds { get => throw null; } + public static Microsoft.CodeAnalysis.DiagnosticDescriptor TemplateHasNoCorrespondingArgument { get => throw null; } + } + public class LoggerMessageGenerator : Microsoft.CodeAnalysis.IIncrementalGenerator + { + public LoggerMessageGenerator() => throw null; + public void Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) => throw null; + } + } + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.JavaScript.JSImportGenerator.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.JavaScript.JSImportGenerator.cs new file mode 100644 index 00000000000..85ecbfcf5b4 --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.JavaScript.JSImportGenerator.cs @@ -0,0 +1,91 @@ +// This file contains auto-generated code. +// Generated from `Microsoft.Interop.JavaScript.JSImportGenerator, Version=7.0.8.36312, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a`. +namespace Microsoft +{ + namespace Interop + { + public class GeneratorDiagnostics : Microsoft.Interop.IGeneratorDiagnostics + { + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ConfigurationValueNotSupported; + public GeneratorDiagnostics() => throw null; + public System.Collections.Generic.IEnumerable Diagnostics { get => throw null; } + public class Ids + { + public const string ConfigurationNotSupported = default; + public Ids() => throw null; + public const string InvalidJSExportAttributeUsage = default; + public const string InvalidJSImportAttributeUsage = default; + public const string JSExportRequiresAllowUnsafeBlocks = default; + public const string JSImportRequiresAllowUnsafeBlocks = default; + public const string Prefix = default; + public const string TypeNotSupported = default; + } + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidExportAttributedMethodContainingTypeMissingModifiers; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidExportAttributedMethodSignature; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidImportAttributedMethodContainingTypeMissingModifiers; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidImportAttributedMethodSignature; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor JSExportRequiresAllowUnsafeBlocks; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor JSImportRequiresAllowUnsafeBlocks; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallingAttributeConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ParameterConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ParameterTypeNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ParameterTypeNotSupportedWithDetails; + public void ReportConfigurationNotSupported(Microsoft.CodeAnalysis.AttributeData attributeData, string configurationName, string unsupportedValue = default(string)) => throw null; + public void ReportInvalidMarshallingAttributeInfo(Microsoft.CodeAnalysis.AttributeData attributeData, string reasonResourceName, params string[] reasonArgs) => throw null; + public void ReportMarshallingNotSupported(Microsoft.Interop.MethodSignatureDiagnosticLocations diagnosticLocations, Microsoft.Interop.TypePositionInfo info, string notSupportedDetails, System.Collections.Immutable.ImmutableDictionary diagnosticProperties) => throw null; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnTypeNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnTypeNotSupportedWithDetails; + } + namespace JavaScript + { + public sealed class JSExportGenerator : Microsoft.CodeAnalysis.IIncrementalGenerator + { + public JSExportGenerator() => throw null; + public void Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) => throw null; + public static class StepNames + { + public const string CalculateStubInformation = default; + public const string GenerateSingleStub = default; + } + } + public sealed class JSImportGenerator : Microsoft.CodeAnalysis.IIncrementalGenerator + { + public JSImportGenerator() => throw null; + public void Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) => throw null; + public static class StepNames + { + public const string CalculateStubInformation = default; + public const string GenerateSingleStub = default; + } + } + public sealed class JSMarshallingAttributeInfoParser + { + public JSMarshallingAttributeInfoParser(Microsoft.CodeAnalysis.Compilation compilation, Microsoft.Interop.IGeneratorDiagnostics diagnostics, Microsoft.CodeAnalysis.ISymbol contextSymbol) => throw null; + public Microsoft.Interop.MarshallingInfo ParseMarshallingInfo(Microsoft.CodeAnalysis.ITypeSymbol managedType, System.Collections.Generic.IEnumerable useSiteAttributes, Microsoft.Interop.MarshallingInfo inner) => throw null; + } + public static class OptionsHelper + { + public const string EnableJSExportOption = default; + public const string EnableJSImportOption = default; + } + } + public sealed class MethodSignatureDiagnosticLocations : System.IEquatable + { + public Microsoft.Interop.MethodSignatureDiagnosticLocations$() => throw null; +public MethodSignatureDiagnosticLocations(string MethodIdentifier, System.Collections.Immutable.ImmutableArray ManagedParameterLocations, Microsoft.CodeAnalysis.Location FallbackLocation) => throw null; + public MethodSignatureDiagnosticLocations(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax syntax) => throw null; + public void Deconstruct(out string MethodIdentifier, out System.Collections.Immutable.ImmutableArray ManagedParameterLocations, out Microsoft.CodeAnalysis.Location FallbackLocation) => throw null; + public bool Equals(Microsoft.Interop.MethodSignatureDiagnosticLocations other) => throw null; + public override bool Equals(object obj) => throw null; + public Microsoft.CodeAnalysis.Location FallbackLocation { get => throw null; set { } } + public override int GetHashCode() => throw null; + public System.Collections.Immutable.ImmutableArray ManagedParameterLocations { get => throw null; set { } } + public string MethodIdentifier { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.MethodSignatureDiagnosticLocations left, Microsoft.Interop.MethodSignatureDiagnosticLocations right) => throw null; + public static bool operator !=(Microsoft.Interop.MethodSignatureDiagnosticLocations left, Microsoft.Interop.MethodSignatureDiagnosticLocations right) => throw null; + public override string ToString() => throw null; + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.LibraryImportGenerator.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.LibraryImportGenerator.cs new file mode 100644 index 00000000000..f3dd0da76de --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.LibraryImportGenerator.cs @@ -0,0 +1,180 @@ +// This file contains auto-generated code. +// Generated from `Microsoft.Interop.LibraryImportGenerator, Version=7.0.8.36312, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a`. +namespace Microsoft +{ + namespace Interop + { + namespace Analyzers + { + public class AddDisableRuntimeMarshallingAttributeFixer : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider + { + public AddDisableRuntimeMarshallingAttributeFixer() => throw null; + public override System.Collections.Immutable.ImmutableArray FixableDiagnosticIds { get => throw null; } + public override Microsoft.CodeAnalysis.CodeFixes.FixAllProvider GetFixAllProvider() => throw null; + public override System.Threading.Tasks.Task RegisterCodeFixesAsync(Microsoft.CodeAnalysis.CodeFixes.CodeFixContext context) => throw null; + } + public class ConvertToLibraryImportAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public const string CharSet = default; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ConvertToLibraryImport; + public ConvertToLibraryImportAnalyzer() => throw null; + public const string ExactSpelling = default; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public const string MayRequireAdditionalWork = default; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + public sealed class ConvertToLibraryImportFixer : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider + { + public ConvertToLibraryImportFixer() => throw null; + public override System.Collections.Immutable.ImmutableArray FixableDiagnosticIds { get => throw null; } + public override Microsoft.CodeAnalysis.CodeFixes.FixAllProvider GetFixAllProvider() => throw null; + public override System.Threading.Tasks.Task RegisterCodeFixesAsync(Microsoft.CodeAnalysis.CodeFixes.CodeFixContext context) => throw null; + } + public class CustomMarshallerAttributeAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor CallerAllocFromManagedMustHaveBufferSizeRule; + public CustomMarshallerAttributeAnalyzer() => throw null; + public static class DefaultMarshalModeDiagnostics + { + public static Microsoft.CodeAnalysis.DiagnosticDescriptor GetDefaultMarshalModeDiagnostic(Microsoft.CodeAnalysis.DiagnosticDescriptor errorDescriptor) => throw null; + } + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ElementMarshallerCannotBeStatefulRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ElementTypesOfReturnTypesMustMatchRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor FirstParameterMustMatchReturnTypeRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor FirstParametersMustMatchRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor FromUnmanagedOverloadsNotSupportedRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor GetPinnableReferenceReturnTypeBlittableRule; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor LinearCollectionInRequiresCollectionMethodsRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor LinearCollectionOutRequiresCollectionMethodsRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ManagedTypeMustBeClosedOrMatchArityRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ManagedTypeMustBeNonNullRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallerTypeMustBeClosedOrMatchArityRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallerTypeMustBeNonNullRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallerTypeMustBeStaticClassOrStructRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallerTypeMustSpecifyManagedTypeRule; + public static class MissingMemberNames + { + public static System.Collections.Immutable.ImmutableDictionary CreateDiagnosticPropertiesForMissingMembersDiagnostic(Microsoft.Interop.MarshalMode mode, params string[] missingMemberNames) => throw null; + public static System.Collections.Immutable.ImmutableDictionary CreateDiagnosticPropertiesForMissingMembersDiagnostic(Microsoft.Interop.MarshalMode mode, System.Collections.Generic.IEnumerable missingMemberNames) => throw null; + public const char Delimiter = default; + public const string Key = default; + public const string MarshalModeKey = default; + } + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor OutRequiresToManagedRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnTypeMustBeExpectedTypeRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnTypesMustMatchRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatefulMarshallerRequiresFreeRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatefulMarshallerRequiresFromManagedRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatefulMarshallerRequiresFromUnmanagedRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatefulMarshallerRequiresToManagedRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatefulMarshallerRequiresToUnmanagedRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatelessLinearCollectionCallerAllocFromManagedMustHaveBufferSizeRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatelessLinearCollectionInRequiresCollectionMethodsRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatelessLinearCollectionOutRequiresCollectionMethodsRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatelessLinearCollectionRequiresTwoParameterAllocateContainerForManagedElementsRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatelessLinearCollectionRequiresTwoParameterAllocateContainerForUnmanagedElementsRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatelessRequiresConvertToManagedRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor StatelessValueInRequiresConvertToUnmanagedRule; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor TypeMustHaveExplicitCastFromVoidPointerRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor UnmanagedTypeMustBeUnmanagedRule; + } + public class CustomMarshallerAttributeFixer : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider + { + public CustomMarshallerAttributeFixer() => throw null; + public override System.Collections.Immutable.ImmutableArray FixableDiagnosticIds { get => throw null; } + public override Microsoft.CodeAnalysis.CodeFixes.FixAllProvider GetFixAllProvider() => throw null; + public override System.Threading.Tasks.Task RegisterCodeFixesAsync(Microsoft.CodeAnalysis.CodeFixes.CodeFixContext context) => throw null; + } + public struct DiagnosticReporter + { + public void CreateAndReportDiagnostic(Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, params object[] messageArgs) => throw null; + public void CreateAndReportDiagnostic(Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, System.Collections.Immutable.ImmutableDictionary properties, params object[] messageArgs) => throw null; + public static Microsoft.Interop.Analyzers.DiagnosticReporter CreateForLocation(Microsoft.CodeAnalysis.Location location, System.Action reportDiagnostic) => throw null; + public DiagnosticReporter(System.Action, object[]> createAndReportDiagnostic) => throw null; + } + public class NativeMarshallingAttributeAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public NativeMarshallingAttributeAnalyzer() => throw null; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor GenericEntryPointMarshallerTypeMustBeClosedOrMatchArityRule; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallerEntryPointTypeMustBeNonNullRule; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallerEntryPointTypeMustHaveCustomMarshallerAttributeWithMatchingManagedTypeRule; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + public class ShapeBreakingDiagnosticSuppressor : Microsoft.CodeAnalysis.Diagnostics.DiagnosticSuppressor + { + public ShapeBreakingDiagnosticSuppressor() => throw null; + public static readonly Microsoft.CodeAnalysis.SuppressionDescriptor MarkMethodsAsStaticSuppression; + public override void ReportSuppressions(Microsoft.CodeAnalysis.Diagnostics.SuppressionAnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedSuppressions { get => throw null; } + } + } + public class GeneratorDiagnostics : Microsoft.Interop.IGeneratorDiagnostics + { + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor CannotForwardToDllImport; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ConfigurationValueNotSupported; + public GeneratorDiagnostics() => throw null; + public System.Collections.Generic.IEnumerable Diagnostics { get => throw null; } + public class Ids + { + public const string CannotForwardToDllImport = default; + public const string ConfigurationNotSupported = default; + public Ids() => throw null; + public const string InvalidLibraryImportAttributeUsage = default; + public const string Prefix = default; + public const string RequiresAllowUnsafeBlocks = default; + public const string TypeNotSupported = default; + } + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidAttributedMethodContainingTypeMissingModifiers; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidAttributedMethodSignature; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor InvalidStringMarshallingConfiguration; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor MarshallingAttributeConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ParameterConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ParameterTypeNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ParameterTypeNotSupportedWithDetails; + public void ReportCannotForwardToDllImport(Microsoft.Interop.MethodSignatureDiagnosticLocations method, string name, string value = default(string)) => throw null; + public void ReportConfigurationNotSupported(Microsoft.CodeAnalysis.AttributeData attributeData, string configurationName, string unsupportedValue = default(string)) => throw null; + public void ReportInvalidMarshallingAttributeInfo(Microsoft.CodeAnalysis.AttributeData attributeData, string reasonResourceName, params string[] reasonArgs) => throw null; + public void ReportInvalidStringMarshallingConfiguration(Microsoft.CodeAnalysis.AttributeData attributeData, string methodName, string detailsMessage) => throw null; + public void ReportMarshallingNotSupported(Microsoft.Interop.MethodSignatureDiagnosticLocations diagnosticLocations, Microsoft.Interop.TypePositionInfo info, string notSupportedDetails, System.Collections.Immutable.ImmutableDictionary diagnosticProperties) => throw null; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor RequiresAllowUnsafeBlocks; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnConfigurationNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnTypeNotSupported; + public static readonly Microsoft.CodeAnalysis.DiagnosticDescriptor ReturnTypeNotSupportedWithDetails; + } + public sealed class LibraryImportGenerator : Microsoft.CodeAnalysis.IIncrementalGenerator + { + public LibraryImportGenerator() => throw null; + public void Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) => throw null; + public static class StepNames + { + public const string CalculateStubInformation = default; + public const string GenerateSingleStub = default; + } + } + public sealed class MethodSignatureDiagnosticLocations : System.IEquatable + { + public Microsoft.Interop.MethodSignatureDiagnosticLocations$() => throw null; +public MethodSignatureDiagnosticLocations(string MethodIdentifier, System.Collections.Immutable.ImmutableArray ManagedParameterLocations, Microsoft.CodeAnalysis.Location FallbackLocation) => throw null; + public MethodSignatureDiagnosticLocations(Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax syntax) => throw null; + public void Deconstruct(out string MethodIdentifier, out System.Collections.Immutable.ImmutableArray ManagedParameterLocations, out Microsoft.CodeAnalysis.Location FallbackLocation) => throw null; + public bool Equals(Microsoft.Interop.MethodSignatureDiagnosticLocations other) => throw null; + public override bool Equals(object obj) => throw null; + public Microsoft.CodeAnalysis.Location FallbackLocation { get => throw null; set { } } + public override int GetHashCode() => throw null; + public System.Collections.Immutable.ImmutableArray ManagedParameterLocations { get => throw null; set { } } + public string MethodIdentifier { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.MethodSignatureDiagnosticLocations left, Microsoft.Interop.MethodSignatureDiagnosticLocations right) => throw null; + public static bool operator !=(Microsoft.Interop.MethodSignatureDiagnosticLocations left, Microsoft.Interop.MethodSignatureDiagnosticLocations right) => throw null; + public override string ToString() => throw null; + } + public static class OptionsHelper + { + public const string GenerateForwardersOption = default; + public const string UseMarshalTypeOption = default; + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.SourceGeneration.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.SourceGeneration.cs new file mode 100644 index 00000000000..fd42badd8c6 --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/Microsoft.Interop.SourceGeneration.cs @@ -0,0 +1,1194 @@ +// This file contains auto-generated code. +// Generated from `Microsoft.Interop.SourceGeneration, Version=7.0.8.36312, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a`. +namespace Microsoft +{ + namespace Interop + { + public class AttributedMarshallingModelGeneratorFactory : Microsoft.Interop.IMarshallingGeneratorFactory + { + public Microsoft.Interop.IMarshallingGenerator Create(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public AttributedMarshallingModelGeneratorFactory(Microsoft.Interop.IMarshallingGeneratorFactory innerMarshallingGenerator, Microsoft.Interop.AttributedMarshallingModelOptions options) => throw null; + public AttributedMarshallingModelGeneratorFactory(Microsoft.Interop.IMarshallingGeneratorFactory innerMarshallingGenerator, Microsoft.Interop.IMarshallingGeneratorFactory elementMarshallingGenerator, Microsoft.Interop.AttributedMarshallingModelOptions options) => throw null; + } + public struct AttributedMarshallingModelOptions : System.IEquatable + { + public AttributedMarshallingModelOptions(bool RuntimeMarshallingDisabled, Microsoft.Interop.MarshalMode InMode, Microsoft.Interop.MarshalMode RefMode, Microsoft.Interop.MarshalMode OutMode) => throw null; + public void Deconstruct(out bool RuntimeMarshallingDisabled, out Microsoft.Interop.MarshalMode InMode, out Microsoft.Interop.MarshalMode RefMode, out Microsoft.Interop.MarshalMode OutMode) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.AttributedMarshallingModelOptions other) => throw null; + public override int GetHashCode() => throw null; + public Microsoft.Interop.MarshalMode InMode { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.AttributedMarshallingModelOptions left, Microsoft.Interop.AttributedMarshallingModelOptions right) => throw null; + public static bool operator !=(Microsoft.Interop.AttributedMarshallingModelOptions left, Microsoft.Interop.AttributedMarshallingModelOptions right) => throw null; + public Microsoft.Interop.MarshalMode OutMode { get => throw null; set { } } + public Microsoft.Interop.MarshalMode RefMode { get => throw null; set { } } + public bool RuntimeMarshallingDisabled { get => throw null; set { } } + public override string ToString() => throw null; + } + public sealed class BlittableMarshaller : Microsoft.Interop.IMarshallingGenerator + { + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info) => throw null; + public BlittableMarshaller() => throw null; + public System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info) => throw null; + public Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version) => throw null; + public bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context) => throw null; + public bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + } + public abstract class BoolMarshallerBase : Microsoft.Interop.IMarshallingGenerator + { + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info) => throw null; + protected BoolMarshallerBase(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax nativeType, int trueValue, int falseValue, bool compareToTrue) => throw null; + public System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info) => throw null; + public Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version) => throw null; + public bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context) => throw null; + public bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + } + public struct BoundGenerator : System.IEquatable + { + public BoundGenerator(Microsoft.Interop.TypePositionInfo TypeInfo, Microsoft.Interop.IMarshallingGenerator Generator) => throw null; + public void Deconstruct(out Microsoft.Interop.TypePositionInfo TypeInfo, out Microsoft.Interop.IMarshallingGenerator Generator) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.BoundGenerator other) => throw null; + public Microsoft.Interop.IMarshallingGenerator Generator { get => throw null; set { } } + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.BoundGenerator left, Microsoft.Interop.BoundGenerator right) => throw null; + public static bool operator !=(Microsoft.Interop.BoundGenerator left, Microsoft.Interop.BoundGenerator right) => throw null; + public override string ToString() => throw null; + public Microsoft.Interop.TypePositionInfo TypeInfo { get => throw null; set { } } + } + public class BoundGenerators + { + public System.Collections.Immutable.ImmutableArray AllMarshallers { get => throw null; } + public BoundGenerators(System.Collections.Immutable.ImmutableArray elementTypeInfo, System.Func generatorFactoryCallback) => throw null; + public (Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax ParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax ReturnType, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax ReturnTypeAttributes) GenerateTargetMethodSignatureData() => throw null; + public bool IsManagedVoidReturn { get => throw null; } + public bool ManagedNativeSameReturn { get => throw null; } + public Microsoft.Interop.BoundGenerator ManagedReturnMarshaller { get => throw null; } + public System.Collections.Immutable.ImmutableArray NativeParameterMarshallers { get => throw null; } + public Microsoft.Interop.BoundGenerator NativeReturnMarshaller { get => throw null; } + } + public sealed class ByteBoolMarshaller : Microsoft.Interop.BoolMarshallerBase + { + public ByteBoolMarshaller(bool signed) : base(default(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax), default(int), default(int), default(bool)) => throw null; + } + [System.Flags] + public enum ByValueContentsMarshalKind + { + Default = 0, + In = 1, + Out = 2, + InOut = 3, + } + public class ByValueContentsMarshalKindValidator : Microsoft.Interop.IMarshallingGeneratorFactory + { + public Microsoft.Interop.IMarshallingGenerator Create(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public ByValueContentsMarshalKindValidator(Microsoft.Interop.IMarshallingGeneratorFactory inner) => throw null; + } + public enum CharEncoding + { + Undefined = 0, + Utf8 = 1, + Utf16 = 2, + Custom = 3, + } + public sealed class CharMarshallingGeneratorFactory : Microsoft.Interop.IMarshallingGeneratorFactory + { + public Microsoft.Interop.IMarshallingGenerator Create(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public CharMarshallingGeneratorFactory(Microsoft.Interop.IMarshallingGeneratorFactory inner, bool useBlittableMarshallerForUtf16) => throw null; + } + public static partial class CompilationExtensions + { + public static Microsoft.Interop.StubEnvironment CreateStubEnvironment(this Microsoft.CodeAnalysis.Compilation compilation) => throw null; + } + public sealed class ConstSizeCountInfo : Microsoft.Interop.CountInfo, System.IEquatable + { + public override Microsoft.Interop.CountInfo$() => throw null; +public ConstSizeCountInfo(int Size) : base(default(Microsoft.Interop.CountInfo)) => throw null; + public void Deconstruct(out int Size) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.CountInfo other) => throw null; + public bool Equals(Microsoft.Interop.ConstSizeCountInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.ConstSizeCountInfo left, Microsoft.Interop.ConstSizeCountInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.ConstSizeCountInfo left, Microsoft.Interop.ConstSizeCountInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public int Size { get => throw null; set { } } + public override string ToString() => throw null; + } + public struct ContainingSyntax : System.IEquatable + { + public ContainingSyntax(Microsoft.CodeAnalysis.SyntaxTokenList Modifiers, Microsoft.CodeAnalysis.CSharp.SyntaxKind TypeKind, Microsoft.CodeAnalysis.SyntaxToken Identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax TypeParameters) => throw null; + public void Deconstruct(out Microsoft.CodeAnalysis.SyntaxTokenList Modifiers, out Microsoft.CodeAnalysis.CSharp.SyntaxKind TypeKind, out Microsoft.CodeAnalysis.SyntaxToken Identifier, out Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax TypeParameters) => throw null; + public bool Equals(Microsoft.Interop.ContainingSyntax other) => throw null; + public override bool Equals(object obj) => throw null; + public override int GetHashCode() => throw null; + public Microsoft.CodeAnalysis.SyntaxToken Identifier { get => throw null; set { } } + public Microsoft.CodeAnalysis.SyntaxTokenList Modifiers { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.ContainingSyntax left, Microsoft.Interop.ContainingSyntax right) => throw null; + public static bool operator !=(Microsoft.Interop.ContainingSyntax left, Microsoft.Interop.ContainingSyntax right) => throw null; + public override string ToString() => throw null; + public Microsoft.CodeAnalysis.CSharp.SyntaxKind TypeKind { get => throw null; set { } } + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax TypeParameters { get => throw null; set { } } + } + public sealed class ContainingSyntaxContext : System.IEquatable + { + public Microsoft.Interop.ContainingSyntaxContext$() => throw null; +public Microsoft.Interop.ContainingSyntaxContext AddContainingSyntax(Microsoft.Interop.ContainingSyntax nestedType) => throw null; + public string ContainingNamespace { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray ContainingSyntax { get => throw null; set { } } + public ContainingSyntaxContext(System.Collections.Immutable.ImmutableArray ContainingSyntax, string ContainingNamespace) => throw null; + public ContainingSyntaxContext(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax memberDeclaration) => throw null; + public void Deconstruct(out System.Collections.Immutable.ImmutableArray ContainingSyntax, out string ContainingNamespace) => throw null; + public bool Equals(Microsoft.Interop.ContainingSyntaxContext other) => throw null; + public override bool Equals(object obj) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.ContainingSyntaxContext left, Microsoft.Interop.ContainingSyntaxContext right) => throw null; + public static bool operator !=(Microsoft.Interop.ContainingSyntaxContext left, Microsoft.Interop.ContainingSyntaxContext right) => throw null; + public override string ToString() => throw null; + public Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax WrapMemberInContainingSyntaxWithUnsafeModifier(Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax member) => throw null; + } + public sealed class CountElementCountInfo : Microsoft.Interop.CountInfo, System.IEquatable + { + public override Microsoft.Interop.CountInfo$() => throw null; +public CountElementCountInfo(Microsoft.Interop.TypePositionInfo ElementInfo) : base(default(Microsoft.Interop.CountInfo)) => throw null; + public void Deconstruct(out Microsoft.Interop.TypePositionInfo ElementInfo) => throw null; + public Microsoft.Interop.TypePositionInfo ElementInfo { get => throw null; set { } } + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.CountInfo other) => throw null; + public bool Equals(Microsoft.Interop.CountElementCountInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.CountElementCountInfo left, Microsoft.Interop.CountElementCountInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.CountElementCountInfo left, Microsoft.Interop.CountElementCountInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public const string ReturnValueElementName = default; + public override string ToString() => throw null; + } + public abstract class CountInfo : System.IEquatable + { + public abstract Microsoft.Interop.CountInfo$(); +protected CountInfo(Microsoft.Interop.CountInfo original) => throw null; + protected virtual System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public virtual bool Equals(Microsoft.Interop.CountInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.CountInfo left, Microsoft.Interop.CountInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.CountInfo left, Microsoft.Interop.CountInfo right) => throw null; + protected virtual bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public struct CustomTypeMarshallerData : System.IEquatable + { + public Microsoft.Interop.ManagedTypeInfo BufferElementType { get => throw null; set { } } + public Microsoft.Interop.MarshallingInfo CollectionElementMarshallingInfo { get => throw null; set { } } + public Microsoft.Interop.ManagedTypeInfo CollectionElementType { get => throw null; set { } } + public CustomTypeMarshallerData(Microsoft.Interop.ManagedTypeInfo MarshallerType, Microsoft.Interop.ManagedTypeInfo NativeType, bool HasState, Microsoft.Interop.MarshallerShape Shape, bool IsStrictlyBlittable, Microsoft.Interop.ManagedTypeInfo BufferElementType, Microsoft.Interop.ManagedTypeInfo CollectionElementType, Microsoft.Interop.MarshallingInfo CollectionElementMarshallingInfo) => throw null; + public void Deconstruct(out Microsoft.Interop.ManagedTypeInfo MarshallerType, out Microsoft.Interop.ManagedTypeInfo NativeType, out bool HasState, out Microsoft.Interop.MarshallerShape Shape, out bool IsStrictlyBlittable, out Microsoft.Interop.ManagedTypeInfo BufferElementType, out Microsoft.Interop.ManagedTypeInfo CollectionElementType, out Microsoft.Interop.MarshallingInfo CollectionElementMarshallingInfo) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.CustomTypeMarshallerData other) => throw null; + public override int GetHashCode() => throw null; + public bool HasState { get => throw null; set { } } + public bool IsStrictlyBlittable { get => throw null; set { } } + public Microsoft.Interop.ManagedTypeInfo MarshallerType { get => throw null; set { } } + public Microsoft.Interop.ManagedTypeInfo NativeType { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.CustomTypeMarshallerData left, Microsoft.Interop.CustomTypeMarshallerData right) => throw null; + public static bool operator !=(Microsoft.Interop.CustomTypeMarshallerData left, Microsoft.Interop.CustomTypeMarshallerData right) => throw null; + public Microsoft.Interop.MarshallerShape Shape { get => throw null; set { } } + public override string ToString() => throw null; + } + public struct CustomTypeMarshallers : System.IEquatable + { + public CustomTypeMarshallers(System.Collections.Immutable.ImmutableDictionary Modes) => throw null; + public void Deconstruct(out System.Collections.Immutable.ImmutableDictionary Modes) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.CustomTypeMarshallers other) => throw null; + public override int GetHashCode() => throw null; + public Microsoft.Interop.CustomTypeMarshallerData GetModeOrDefault(Microsoft.Interop.MarshalMode mode) => throw null; + public bool IsDefinedOrDefault(Microsoft.Interop.MarshalMode mode) => throw null; + public System.Collections.Immutable.ImmutableDictionary Modes { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.CustomTypeMarshallers left, Microsoft.Interop.CustomTypeMarshallers right) => throw null; + public static bool operator !=(Microsoft.Interop.CustomTypeMarshallers left, Microsoft.Interop.CustomTypeMarshallers right) => throw null; + public override string ToString() => throw null; + public bool TryGetModeOrDefault(Microsoft.Interop.MarshalMode mode, out Microsoft.Interop.CustomTypeMarshallerData data) => throw null; + } + [System.Flags] + public enum CustomTypeMarshallingDirection + { + None = 0, + In = 1, + Out = 2, + Ref = 3, + } + public sealed class DefaultMarshallingInfo : System.IEquatable + { + public Microsoft.Interop.DefaultMarshallingInfo$() => throw null; +public Microsoft.Interop.CharEncoding CharEncoding { get => throw null; set { } } + public DefaultMarshallingInfo(Microsoft.Interop.CharEncoding CharEncoding, Microsoft.CodeAnalysis.INamedTypeSymbol StringMarshallingCustomType) => throw null; + public void Deconstruct(out Microsoft.Interop.CharEncoding CharEncoding, out Microsoft.CodeAnalysis.INamedTypeSymbol StringMarshallingCustomType) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.DefaultMarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.DefaultMarshallingInfo left, Microsoft.Interop.DefaultMarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.DefaultMarshallingInfo left, Microsoft.Interop.DefaultMarshallingInfo right) => throw null; + public Microsoft.CodeAnalysis.INamedTypeSymbol StringMarshallingCustomType { get => throw null; set { } } + public override string ToString() => throw null; + } + public sealed class DelegateMarshaller : Microsoft.Interop.IMarshallingGenerator + { + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info) => throw null; + public DelegateMarshaller() => throw null; + public System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info) => throw null; + public Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version) => throw null; + public bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context) => throw null; + public bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + } + public sealed class DelegateTypeInfo : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public DelegateTypeInfo(string FullTypeName, string DiagnosticFormattedName) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public bool Equals(Microsoft.Interop.DelegateTypeInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.DelegateTypeInfo left, Microsoft.Interop.DelegateTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.DelegateTypeInfo left, Microsoft.Interop.DelegateTypeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public static partial class DiagnosticExtensions + { + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, params object[] args) => throw null; + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, System.Collections.Immutable.ImmutableDictionary properties, params object[] args) => throw null; + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this Microsoft.CodeAnalysis.AttributeData attributeData, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, params object[] args) => throw null; + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this Microsoft.CodeAnalysis.AttributeData attributeData, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, System.Collections.Immutable.ImmutableDictionary properties, params object[] args) => throw null; + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this System.Collections.Immutable.ImmutableArray locations, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, params object[] args) => throw null; + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this System.Collections.Immutable.ImmutableArray locations, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, System.Collections.Immutable.ImmutableDictionary properties, params object[] args) => throw null; + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this Microsoft.CodeAnalysis.Location location, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, params object[] args) => throw null; + public static Microsoft.CodeAnalysis.Diagnostic CreateDiagnostic(this Microsoft.CodeAnalysis.Location location, Microsoft.CodeAnalysis.DiagnosticDescriptor descriptor, System.Collections.Immutable.ImmutableDictionary properties, params object[] args) => throw null; + } + public sealed class EnumTypeInfo : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public EnumTypeInfo(string FullTypeName, string DiagnosticFormattedName, Microsoft.CodeAnalysis.SpecialType UnderlyingType) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName, out Microsoft.CodeAnalysis.SpecialType UnderlyingType) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public bool Equals(Microsoft.Interop.EnumTypeInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.EnumTypeInfo left, Microsoft.Interop.EnumTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.EnumTypeInfo left, Microsoft.Interop.EnumTypeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + public Microsoft.CodeAnalysis.SpecialType UnderlyingType { get => throw null; set { } } + } + public sealed class Forwarder : Microsoft.Interop.IMarshallingGenerator + { + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info) => throw null; + public Forwarder() => throw null; + public System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info) => throw null; + public Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version) => throw null; + public bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context) => throw null; + public bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + } + public struct GeneratedStatements + { + public System.Collections.Immutable.ImmutableArray Cleanup { get => throw null; set { } } + public static Microsoft.Interop.GeneratedStatements Create(Microsoft.Interop.BoundGenerators marshallers, Microsoft.Interop.StubCodeContext context, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionToInvoke) => throw null; + public System.Collections.Immutable.ImmutableArray GuaranteedUnmarshal { get => throw null; set { } } + public Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax InvokeStatement { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray Marshal { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray NotifyForSuccessfulInvoke { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray Pin { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray PinnedMarshal { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray Setup { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray Unmarshal { get => throw null; set { } } + } + public class GeneratorDiagnosticProperties + { + public const string AddDisableRuntimeMarshallingAttribute = default; + public GeneratorDiagnosticProperties() => throw null; + } + public interface IGeneratorDiagnostics + { + void ReportConfigurationNotSupported(Microsoft.CodeAnalysis.AttributeData attributeData, string configurationName, string unsupportedValue); + void ReportInvalidMarshallingAttributeInfo(Microsoft.CodeAnalysis.AttributeData attributeData, string reasonResourceName, params string[] reasonArgs); + } + public static partial class IGeneratorDiagnosticsExtensions + { + public static void ReportConfigurationNotSupported(this Microsoft.Interop.IGeneratorDiagnostics diagnostics, Microsoft.CodeAnalysis.AttributeData attributeData, string configurationName) => throw null; + } + public interface IMarshallingGenerator + { + Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info); + System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context); + Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info); + Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context); + bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version); + bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context); + bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context); + } + public interface IMarshallingGeneratorFactory + { + Microsoft.Interop.IMarshallingGenerator Create(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context); + } + public static partial class IncrementalGeneratorInitializationContextExtensions + { + public static Microsoft.CodeAnalysis.IncrementalValueProvider CreateStubEnvironmentProvider(this Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) => throw null; + public static void RegisterConcatenatedSyntaxOutputs(this Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context, Microsoft.CodeAnalysis.IncrementalValuesProvider nodes, string fileName) where TNode : Microsoft.CodeAnalysis.SyntaxNode => throw null; + public static void RegisterDiagnostics(this Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context, Microsoft.CodeAnalysis.IncrementalValuesProvider diagnostics) => throw null; + } + public class InteropAttributeData : System.IEquatable + { + public virtual Microsoft.Interop.InteropAttributeData$() => throw null; +protected InteropAttributeData(Microsoft.Interop.InteropAttributeData original) => throw null; + public InteropAttributeData() => throw null; + protected virtual System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public virtual bool Equals(Microsoft.Interop.InteropAttributeData other) => throw null; + public override int GetHashCode() => throw null; + public Microsoft.Interop.InteropAttributeMember IsUserDefined { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.InteropAttributeData left, Microsoft.Interop.InteropAttributeData right) => throw null; + public static bool operator !=(Microsoft.Interop.InteropAttributeData left, Microsoft.Interop.InteropAttributeData right) => throw null; + protected virtual bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public bool SetLastError { get => throw null; set { } } + public Microsoft.Interop.StringMarshalling StringMarshalling { get => throw null; set { } } + public Microsoft.CodeAnalysis.INamedTypeSymbol StringMarshallingCustomType { get => throw null; set { } } + public override string ToString() => throw null; + } + public static partial class InteropAttributeDataExtensions + { + public static T WithValuesFromNamedArguments(this T t, System.Collections.Immutable.ImmutableDictionary namedArguments) where T : Microsoft.Interop.InteropAttributeData => throw null; + } + [System.Flags] + public enum InteropAttributeMember + { + None = 0, + SetLastError = 1, + StringMarshalling = 2, + StringMarshallingCustomType = 4, + All = -1, + } + public struct InteropGenerationOptions : System.IEquatable + { + public InteropGenerationOptions(bool UseMarshalType) => throw null; + public void Deconstruct(out bool UseMarshalType) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.InteropGenerationOptions other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.InteropGenerationOptions left, Microsoft.Interop.InteropGenerationOptions right) => throw null; + public static bool operator !=(Microsoft.Interop.InteropGenerationOptions left, Microsoft.Interop.InteropGenerationOptions right) => throw null; + public override string ToString() => throw null; + public bool UseMarshalType { get => throw null; set { } } + } + public sealed class ManagedToNativeStubCodeContext : Microsoft.Interop.StubCodeContext, System.IEquatable + { + public override Microsoft.Interop.StubCodeContext$() => throw null; +public override bool AdditionalTemporaryStateLivesAcrossStages { get => throw null; } + public ManagedToNativeStubCodeContext(Microsoft.Interop.StubEnvironment environment, string returnIdentifier, string nativeReturnIdentifier) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.StubCodeContext other) => throw null; + public bool Equals(Microsoft.Interop.ManagedToNativeStubCodeContext other) => throw null; + public override int GetHashCode() => throw null; + public override (string managed, string native) GetIdentifiers(Microsoft.Interop.TypePositionInfo info) => throw null; + public override (Microsoft.Interop.TargetFramework framework, System.Version version) GetTargetFramework() => throw null; + public static bool operator ==(Microsoft.Interop.ManagedToNativeStubCodeContext left, Microsoft.Interop.ManagedToNativeStubCodeContext right) => throw null; + public static bool operator !=(Microsoft.Interop.ManagedToNativeStubCodeContext left, Microsoft.Interop.ManagedToNativeStubCodeContext right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override bool SingleFrameSpansNativeContext { get => throw null; } + public override string ToString() => throw null; + } + public abstract class ManagedTypeInfo : System.IEquatable + { + public abstract Microsoft.Interop.ManagedTypeInfo$(); +public static Microsoft.Interop.ManagedTypeInfo CreateTypeInfoForTypeSymbol(Microsoft.CodeAnalysis.ITypeSymbol type) => throw null; + protected ManagedTypeInfo(string FullTypeName, string DiagnosticFormattedName) => throw null; + protected ManagedTypeInfo(Microsoft.Interop.ManagedTypeInfo original) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName) => throw null; + public string DiagnosticFormattedName { get => throw null; set { } } + protected virtual System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public virtual bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public string FullTypeName { get => throw null; set { } } + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.ManagedTypeInfo left, Microsoft.Interop.ManagedTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.ManagedTypeInfo left, Microsoft.Interop.ManagedTypeInfo right) => throw null; + protected virtual bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax Syntax { get => throw null; } + public override string ToString() => throw null; + } + public static class ManualTypeMarshallingHelper + { + public static bool HasEntryPointMarshallerAttribute(Microsoft.CodeAnalysis.ITypeSymbol entryPointType) => throw null; + public static bool IsLinearCollectionEntryPoint(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType) => throw null; + public static class MarshalUsingProperties + { + public const string ConstantElementCount = default; + public const string CountElementName = default; + public const string ElementIndirectionDepth = default; + } + public static bool ModeUsesManagedToUnmanagedShape(Microsoft.Interop.MarshalMode mode) => throw null; + public static bool ModeUsesUnmanagedToManagedShape(Microsoft.Interop.MarshalMode mode) => throw null; + public static Microsoft.CodeAnalysis.ITypeSymbol ReplaceGenericPlaceholderInType(Microsoft.CodeAnalysis.ITypeSymbol managedType, Microsoft.CodeAnalysis.INamedTypeSymbol entryType, Microsoft.CodeAnalysis.Compilation compilation) => throw null; + public static bool TryGetLinearCollectionMarshallersFromEntryType(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType, Microsoft.CodeAnalysis.ITypeSymbol managedType, Microsoft.CodeAnalysis.Compilation compilation, System.Func getMarshallingInfo, out Microsoft.Interop.CustomTypeMarshallers? marshallers) => throw null; + public static bool TryGetLinearCollectionMarshallersFromEntryType(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType, Microsoft.CodeAnalysis.ITypeSymbol managedType, Microsoft.CodeAnalysis.Compilation compilation, System.Func getMarshallingInfo, System.Action onArityMismatch, out Microsoft.Interop.CustomTypeMarshallers? marshallers) => throw null; + public static bool TryGetMarshallersFromEntryTypeIgnoringElements(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType, Microsoft.CodeAnalysis.ITypeSymbol managedType, Microsoft.CodeAnalysis.Compilation compilation, System.Action onArityMismatch, out Microsoft.Interop.CustomTypeMarshallers? marshallers) => throw null; + public static bool TryGetValueMarshallersFromEntryType(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType, Microsoft.CodeAnalysis.ITypeSymbol managedType, Microsoft.CodeAnalysis.Compilation compilation, out Microsoft.Interop.CustomTypeMarshallers? marshallers) => throw null; + public static bool TryGetValueMarshallersFromEntryType(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType, Microsoft.CodeAnalysis.ITypeSymbol managedType, Microsoft.CodeAnalysis.Compilation compilation, System.Action onArityMismatch, out Microsoft.Interop.CustomTypeMarshallers? marshallers) => throw null; + public static bool TryResolveEntryPointType(Microsoft.CodeAnalysis.INamedTypeSymbol managedType, Microsoft.CodeAnalysis.ITypeSymbol typeInAttribute, bool isLinearCollectionMarshalling, System.Action onArityMismatch, out Microsoft.CodeAnalysis.ITypeSymbol entryPoint) => throw null; + public static bool TryResolveManagedType(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType, Microsoft.CodeAnalysis.ITypeSymbol typeInAttribute, bool isLinearCollectionMarshalling, System.Action onArityMismatch, out Microsoft.CodeAnalysis.ITypeSymbol managed) => throw null; + public static bool TryResolveMarshallerType(Microsoft.CodeAnalysis.INamedTypeSymbol entryPointType, Microsoft.CodeAnalysis.ITypeSymbol typeInAttribute, System.Action onArityMismatch, out Microsoft.CodeAnalysis.ITypeSymbol marshallerType) => throw null; + } + public sealed class MarshalAsInfo : Microsoft.Interop.MarshallingInfoStringSupport, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +public MarshalAsInfo(System.Runtime.InteropServices.UnmanagedType UnmanagedType, Microsoft.Interop.CharEncoding CharEncoding) : base(default(Microsoft.Interop.CharEncoding)) => throw null; + public void Deconstruct(out System.Runtime.InteropServices.UnmanagedType UnmanagedType, out Microsoft.Interop.CharEncoding CharEncoding) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MarshallingInfoStringSupport other) => throw null; + public bool Equals(Microsoft.Interop.MarshalAsInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.MarshalAsInfo left, Microsoft.Interop.MarshalAsInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.MarshalAsInfo left, Microsoft.Interop.MarshalAsInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + public System.Runtime.InteropServices.UnmanagedType UnmanagedType { get => throw null; set { } } + } + public sealed class MarshalAsMarshallingGeneratorFactory : Microsoft.Interop.IMarshallingGeneratorFactory + { + public Microsoft.Interop.IMarshallingGenerator Create(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public MarshalAsMarshallingGeneratorFactory(Microsoft.Interop.InteropGenerationOptions options, Microsoft.Interop.IMarshallingGeneratorFactory inner) => throw null; + } + public static class MarshallerHelpers + { + public static Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax CreateClearLastSystemErrorStatement(int errorCode) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax CreateGetLastSystemErrorStatement(string lastErrorIdentifier) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax CreateSetLastPInvokeErrorStatement(string lastErrorIdentifier) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax Declare(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax typeSyntax, string identifier, bool initializeToDefault) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax Declare(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax typeSyntax, string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax initializer) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax GetCompatibleGenericTypeParameterSyntax(this Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) => throw null; + public static System.Collections.Generic.IEnumerable GetDependentElementsOfMarshallingInfo(Microsoft.Interop.MarshallingInfo elementMarshallingInfo) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax GetForLoop(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax lengthExpression, string indexerIdentifier) => throw null; + public static string GetLastIndexMarshalledIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public static string GetManagedSpanIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public static string GetMarshallerIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public static string GetNativeSpanIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public static string GetNumElementsIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public static Microsoft.CodeAnalysis.RefKind GetRefKindForByValueContentsKind(this Microsoft.Interop.ByValueContentsMarshalKind byValue) => throw null; + public static System.Collections.Generic.IEnumerable GetTopologicallySortedElements(System.Collections.Generic.ICollection elements, System.Func keyFn, System.Func> getDependentIndicesFn) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax SkipInitOrDefaultInit(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public static readonly Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax SystemIntPtrType; + } + [System.Flags] + public enum MarshallerShape + { + None = 0, + ToUnmanaged = 1, + CallerAllocatedBuffer = 2, + StatelessPinnableReference = 4, + StatefulPinnableReference = 8, + ToManaged = 16, + GuaranteedUnmarshal = 32, + Free = 64, + OnInvoked = 128, + } + public sealed class MarshallingAttributeInfoParser + { + public MarshallingAttributeInfoParser(Microsoft.CodeAnalysis.Compilation compilation, Microsoft.Interop.IGeneratorDiagnostics diagnostics, Microsoft.Interop.DefaultMarshallingInfo defaultInfo, Microsoft.CodeAnalysis.ISymbol contextSymbol) => throw null; + public Microsoft.Interop.MarshallingInfo ParseMarshallingInfo(Microsoft.CodeAnalysis.ITypeSymbol managedType, System.Collections.Generic.IEnumerable useSiteAttributes) => throw null; + } + public static partial class MarshallingGeneratorExtensions + { + public static Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax AsArgument(this Microsoft.Interop.IMarshallingGenerator generator, Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax AsParameter(this Microsoft.Interop.IMarshallingGenerator generator, Microsoft.Interop.TypePositionInfo info) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsReturnType(this Microsoft.Interop.IMarshallingGenerator generator, Microsoft.Interop.TypePositionInfo info) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax GenerateAttributesForReturnType(this Microsoft.Interop.IMarshallingGenerator generator, Microsoft.Interop.TypePositionInfo info) => throw null; + } + public struct MarshallingGeneratorFactoryKey : System.IEquatable> where T : System.IEquatable + { + public bool Equals(Microsoft.Interop.MarshallingGeneratorFactoryKey other) => throw null; + public override bool Equals(object obj) => throw null; + public Microsoft.Interop.IMarshallingGeneratorFactory GeneratorFactory { get => throw null; set { } } + public override int GetHashCode() => throw null; + public T Key { get => throw null; set { } } + } + public static class MarshallingGeneratorFactoryKey + { + public static Microsoft.Interop.MarshallingGeneratorFactoryKey Create(T key, Microsoft.Interop.IMarshallingGeneratorFactory factory) where T : System.IEquatable => throw null; + } + public abstract class MarshallingInfo : System.IEquatable + { + public abstract Microsoft.Interop.MarshallingInfo$(); +protected MarshallingInfo() => throw null; + protected MarshallingInfo(Microsoft.Interop.MarshallingInfo original) => throw null; + protected virtual System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public virtual bool Equals(Microsoft.Interop.MarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.MarshallingInfo left, Microsoft.Interop.MarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.MarshallingInfo left, Microsoft.Interop.MarshallingInfo right) => throw null; + protected virtual bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public class MarshallingInfoStringSupport : Microsoft.Interop.MarshallingInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +public Microsoft.Interop.CharEncoding CharEncoding { get => throw null; set { } } + public MarshallingInfoStringSupport(Microsoft.Interop.CharEncoding CharEncoding) => throw null; + protected MarshallingInfoStringSupport(Microsoft.Interop.MarshallingInfoStringSupport original) => throw null; + public void Deconstruct(out Microsoft.Interop.CharEncoding CharEncoding) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MarshallingInfo other) => throw null; + public virtual bool Equals(Microsoft.Interop.MarshallingInfoStringSupport other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.MarshallingInfoStringSupport left, Microsoft.Interop.MarshallingInfoStringSupport right) => throw null; + public static bool operator !=(Microsoft.Interop.MarshallingInfoStringSupport left, Microsoft.Interop.MarshallingInfoStringSupport right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class MarshallingNotSupportedException : System.Exception + { + public MarshallingNotSupportedException(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public System.Collections.Immutable.ImmutableDictionary DiagnosticProperties { get => throw null; set { } } + public string NotSupportedDetails { get => throw null; set { } } + public Microsoft.Interop.StubCodeContext StubCodeContext { get => throw null; } + public Microsoft.Interop.TypePositionInfo TypePositionInfo { get => throw null; } + } + public enum MarshalMode + { + Default = 0, + ManagedToUnmanagedIn = 1, + ManagedToUnmanagedRef = 2, + ManagedToUnmanagedOut = 3, + UnmanagedToManagedIn = 4, + UnmanagedToManagedRef = 5, + UnmanagedToManagedOut = 6, + ElementIn = 7, + ElementRef = 8, + ElementOut = 9, + } + public sealed class MissingSupportCollectionMarshallingInfo : Microsoft.Interop.MissingSupportMarshallingInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +public Microsoft.Interop.CountInfo CountInfo { get => throw null; set { } } + public MissingSupportCollectionMarshallingInfo(Microsoft.Interop.CountInfo CountInfo, Microsoft.Interop.MarshallingInfo ElementMarshallingInfo) => throw null; + public void Deconstruct(out Microsoft.Interop.CountInfo CountInfo, out Microsoft.Interop.MarshallingInfo ElementMarshallingInfo) => throw null; + public Microsoft.Interop.MarshallingInfo ElementMarshallingInfo { get => throw null; set { } } + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MissingSupportMarshallingInfo other) => throw null; + public bool Equals(Microsoft.Interop.MissingSupportCollectionMarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.MissingSupportCollectionMarshallingInfo left, Microsoft.Interop.MissingSupportCollectionMarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.MissingSupportCollectionMarshallingInfo left, Microsoft.Interop.MissingSupportCollectionMarshallingInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public class MissingSupportMarshallingInfo : Microsoft.Interop.MarshallingInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +protected MissingSupportMarshallingInfo(Microsoft.Interop.MissingSupportMarshallingInfo original) => throw null; + public MissingSupportMarshallingInfo() => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MarshallingInfo other) => throw null; + public virtual bool Equals(Microsoft.Interop.MissingSupportMarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.MissingSupportMarshallingInfo left, Microsoft.Interop.MissingSupportMarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.MissingSupportMarshallingInfo left, Microsoft.Interop.MissingSupportMarshallingInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class NativeLinearCollectionMarshallingInfo : Microsoft.Interop.NativeMarshallingAttributeInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +public NativeLinearCollectionMarshallingInfo(Microsoft.Interop.ManagedTypeInfo EntryPointType, Microsoft.Interop.CustomTypeMarshallers Marshallers, Microsoft.Interop.CountInfo ElementCountInfo, Microsoft.Interop.ManagedTypeInfo PlaceholderTypeParameter) : base(default(Microsoft.Interop.NativeMarshallingAttributeInfo)) => throw null; + public void Deconstruct(out Microsoft.Interop.ManagedTypeInfo EntryPointType, out Microsoft.Interop.CustomTypeMarshallers Marshallers, out Microsoft.Interop.CountInfo ElementCountInfo, out Microsoft.Interop.ManagedTypeInfo PlaceholderTypeParameter) => throw null; + public Microsoft.Interop.CountInfo ElementCountInfo { get => throw null; set { } } + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.NativeMarshallingAttributeInfo other) => throw null; + public bool Equals(Microsoft.Interop.NativeLinearCollectionMarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.NativeLinearCollectionMarshallingInfo left, Microsoft.Interop.NativeLinearCollectionMarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.NativeLinearCollectionMarshallingInfo left, Microsoft.Interop.NativeLinearCollectionMarshallingInfo right) => throw null; + public Microsoft.Interop.ManagedTypeInfo PlaceholderTypeParameter { get => throw null; set { } } + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public class NativeMarshallingAttributeInfo : Microsoft.Interop.MarshallingInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +public NativeMarshallingAttributeInfo(Microsoft.Interop.ManagedTypeInfo EntryPointType, Microsoft.Interop.CustomTypeMarshallers Marshallers) => throw null; + protected NativeMarshallingAttributeInfo(Microsoft.Interop.NativeMarshallingAttributeInfo original) => throw null; + public void Deconstruct(out Microsoft.Interop.ManagedTypeInfo EntryPointType, out Microsoft.Interop.CustomTypeMarshallers Marshallers) => throw null; + public Microsoft.Interop.ManagedTypeInfo EntryPointType { get => throw null; set { } } + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MarshallingInfo other) => throw null; + public virtual bool Equals(Microsoft.Interop.NativeMarshallingAttributeInfo other) => throw null; + public override int GetHashCode() => throw null; + public Microsoft.Interop.CustomTypeMarshallers Marshallers { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.NativeMarshallingAttributeInfo left, Microsoft.Interop.NativeMarshallingAttributeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.NativeMarshallingAttributeInfo left, Microsoft.Interop.NativeMarshallingAttributeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class NoCountInfo : Microsoft.Interop.CountInfo, System.IEquatable + { + public override Microsoft.Interop.CountInfo$() => throw null; +protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.CountInfo other) => throw null; + public bool Equals(Microsoft.Interop.NoCountInfo other) => throw null; + public override int GetHashCode() => throw null; + public static readonly Microsoft.Interop.NoCountInfo Instance; + public static bool operator ==(Microsoft.Interop.NoCountInfo left, Microsoft.Interop.NoCountInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.NoCountInfo left, Microsoft.Interop.NoCountInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + internal NoCountInfo() : base(default(Microsoft.Interop.CountInfo)) { } + } + public sealed class NoMarshallingInfo : Microsoft.Interop.MarshallingInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MarshallingInfo other) => throw null; + public bool Equals(Microsoft.Interop.NoMarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public static readonly Microsoft.Interop.MarshallingInfo Instance; + public static bool operator ==(Microsoft.Interop.NoMarshallingInfo left, Microsoft.Interop.NoMarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.NoMarshallingInfo left, Microsoft.Interop.NoMarshallingInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class NoMarshallingInfoErrorMarshallingFactory : Microsoft.Interop.IMarshallingGeneratorFactory + { + public Microsoft.Interop.IMarshallingGenerator Create(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public NoMarshallingInfoErrorMarshallingFactory(Microsoft.Interop.IMarshallingGeneratorFactory inner) => throw null; + public System.Collections.Immutable.ImmutableDictionary CustomTypeToErrorMessageMap { get => throw null; } + } + public sealed class PointerTypeInfo : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public PointerTypeInfo(string FullTypeName, string DiagnosticFormattedName, bool IsFunctionPointer) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName, out bool IsFunctionPointer) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public bool Equals(Microsoft.Interop.PointerTypeInfo other) => throw null; + public override int GetHashCode() => throw null; + public bool IsFunctionPointer { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.PointerTypeInfo left, Microsoft.Interop.PointerTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.PointerTypeInfo left, Microsoft.Interop.PointerTypeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class ReferenceTypeInfo : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public ReferenceTypeInfo(string FullTypeName, string DiagnosticFormattedName) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public bool Equals(Microsoft.Interop.ReferenceTypeInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.ReferenceTypeInfo left, Microsoft.Interop.ReferenceTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.ReferenceTypeInfo left, Microsoft.Interop.ReferenceTypeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class SafeHandleMarshaller : Microsoft.Interop.IMarshallingGenerator + { + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info) => throw null; + public SafeHandleMarshaller() => throw null; + public System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info) => throw null; + public Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version) => throw null; + public bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context) => throw null; + public bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + } + public sealed class SafeHandleMarshallingInfo : Microsoft.Interop.MarshallingInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +public bool AccessibleDefaultConstructor { get => throw null; set { } } + public SafeHandleMarshallingInfo(bool AccessibleDefaultConstructor, bool IsAbstract) => throw null; + public void Deconstruct(out bool AccessibleDefaultConstructor, out bool IsAbstract) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MarshallingInfo other) => throw null; + public bool Equals(Microsoft.Interop.SafeHandleMarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public bool IsAbstract { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.SafeHandleMarshallingInfo left, Microsoft.Interop.SafeHandleMarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.SafeHandleMarshallingInfo left, Microsoft.Interop.SafeHandleMarshallingInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public static class ShapeMemberNames + { + public const string BufferSize = default; + public const string Free = default; + public const string GetPinnableReference = default; + public static class LinearCollection + { + public static class Stateful + { + public const string Free = default; + public const string FromManaged = default; + public const string FromUnmanaged = default; + public const string GetManagedValuesDestination = default; + public const string GetManagedValuesSource = default; + public const string GetUnmanagedValuesDestination = default; + public const string GetUnmanagedValuesSource = default; + public const string OnInvoked = default; + public const string ToManaged = default; + public const string ToManagedFinally = default; + public const string ToUnmanaged = default; + } + public static class Stateless + { + public const string AllocateContainerForManagedElements = default; + public const string AllocateContainerForManagedElementsFinally = default; + public const string AllocateContainerForUnmanagedElements = default; + public const string GetManagedValuesDestination = default; + public const string GetManagedValuesSource = default; + public const string GetUnmanagedValuesDestination = default; + public const string GetUnmanagedValuesSource = default; + } + } + public static class Value + { + public static class Stateful + { + public const string Free = default; + public const string FromManaged = default; + public const string FromUnmanaged = default; + public const string OnInvoked = default; + public const string ToManaged = default; + public const string ToManagedFinally = default; + public const string ToUnmanaged = default; + } + public static class Stateless + { + public const string ConvertToManaged = default; + public const string ConvertToManagedFinally = default; + public const string ConvertToUnmanaged = default; + } + } + } + public enum SignatureBehavior + { + ManagedTypeAndAttributes = 0, + NativeType = 1, + PointerToNativeType = 2, + } + public sealed class SignatureContext : System.IEquatable + { + public Microsoft.Interop.SignatureContext$() => throw null; +public System.Collections.Immutable.ImmutableArray AdditionalAttributes { get => throw null; set { } } + public static Microsoft.Interop.SignatureContext Create(Microsoft.CodeAnalysis.IMethodSymbol method, Microsoft.Interop.InteropAttributeData interopAttributeData, Microsoft.Interop.StubEnvironment env, Microsoft.Interop.IGeneratorDiagnostics diagnostics, System.Reflection.Assembly generatorInfoAssembly) => throw null; + public System.Collections.Immutable.ImmutableArray ElementTypeInformation { get => throw null; set { } } + public bool Equals(Microsoft.Interop.SignatureContext other) => throw null; + public override bool Equals(object obj) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.SignatureContext left, Microsoft.Interop.SignatureContext right) => throw null; + public static bool operator !=(Microsoft.Interop.SignatureContext left, Microsoft.Interop.SignatureContext right) => throw null; + public System.Collections.Generic.IEnumerable StubParameters { get => throw null; } + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax StubReturnType { get => throw null; set { } } + public override string ToString() => throw null; + } + public sealed class SizeAndParamIndexInfo : Microsoft.Interop.CountInfo, System.IEquatable + { + public override Microsoft.Interop.CountInfo$() => throw null; +public int ConstSize { get => throw null; set { } } + public SizeAndParamIndexInfo(int ConstSize, Microsoft.Interop.TypePositionInfo ParamAtIndex) : base(default(Microsoft.Interop.CountInfo)) => throw null; + public void Deconstruct(out int ConstSize, out Microsoft.Interop.TypePositionInfo ParamAtIndex) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.CountInfo other) => throw null; + public bool Equals(Microsoft.Interop.SizeAndParamIndexInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.SizeAndParamIndexInfo left, Microsoft.Interop.SizeAndParamIndexInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.SizeAndParamIndexInfo left, Microsoft.Interop.SizeAndParamIndexInfo right) => throw null; + public Microsoft.Interop.TypePositionInfo ParamAtIndex { get => throw null; set { } } + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + public static readonly Microsoft.Interop.SizeAndParamIndexInfo Unspecified; + public const int UnspecifiedConstSize = -1; + public const Microsoft.Interop.TypePositionInfo UnspecifiedParam = default; + } + public sealed class SpecialTypeInfo : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public static readonly Microsoft.Interop.SpecialTypeInfo Boolean; + public static readonly Microsoft.Interop.SpecialTypeInfo Byte; + public SpecialTypeInfo(string FullTypeName, string DiagnosticFormattedName, Microsoft.CodeAnalysis.SpecialType SpecialType) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName, out Microsoft.CodeAnalysis.SpecialType SpecialType) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public bool Equals(Microsoft.Interop.SpecialTypeInfo other) => throw null; + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public override int GetHashCode() => throw null; + public static readonly Microsoft.Interop.SpecialTypeInfo Int32; + public static bool operator ==(Microsoft.Interop.SpecialTypeInfo left, Microsoft.Interop.SpecialTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.SpecialTypeInfo left, Microsoft.Interop.SpecialTypeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public Microsoft.CodeAnalysis.SpecialType SpecialType { get => throw null; set { } } + public static readonly Microsoft.Interop.SpecialTypeInfo String; + public override string ToString() => throw null; + public static readonly Microsoft.Interop.SpecialTypeInfo Void; + } + public static class StatefulMarshallerShapeHelper + { + public static System.Collections.Immutable.ImmutableArray GetFromUnmanagedMethodCandidates(Microsoft.CodeAnalysis.ITypeSymbol type) => throw null; + public static (Microsoft.Interop.MarshallerShape shape, Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods methods) GetShapeForType(Microsoft.CodeAnalysis.ITypeSymbol marshallerType, Microsoft.CodeAnalysis.ITypeSymbol managedType, bool isLinearCollectionMarshaller, Microsoft.CodeAnalysis.Compilation compilation) => throw null; + public class MarshallerMethods : System.IEquatable + { + public virtual Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods$() => throw null; +protected MarshallerMethods(Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods original) => throw null; + public MarshallerMethods() => throw null; + protected virtual System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public virtual bool Equals(Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods other) => throw null; + public Microsoft.CodeAnalysis.IMethodSymbol Free { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol FromManaged { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol FromManagedWithBuffer { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol FromUnmanaged { get => throw null; set { } } + public override int GetHashCode() => throw null; + public bool IsShapeMethod(Microsoft.CodeAnalysis.IMethodSymbol method) => throw null; + public Microsoft.CodeAnalysis.IMethodSymbol ManagedValuesDestination { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol ManagedValuesSource { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol OnInvoked { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods left, Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods right) => throw null; + public static bool operator !=(Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods left, Microsoft.Interop.StatefulMarshallerShapeHelper.MarshallerMethods right) => throw null; + protected virtual bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public Microsoft.CodeAnalysis.IMethodSymbol StatefulGetPinnableReference { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol StatelessGetPinnableReference { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol ToManaged { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol ToManagedGuaranteed { get => throw null; set { } } + public override string ToString() => throw null; + public Microsoft.CodeAnalysis.IMethodSymbol ToUnmanaged { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol UnmanagedValuesDestination { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol UnmanagedValuesSource { get => throw null; set { } } + } + } + public static class StatelessMarshallerShapeHelper + { + public static (Microsoft.Interop.MarshallerShape, Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods) GetShapeForType(Microsoft.CodeAnalysis.ITypeSymbol marshallerType, Microsoft.CodeAnalysis.ITypeSymbol managedType, bool isLinearCollectionMarshaller, Microsoft.CodeAnalysis.Compilation compilation) => throw null; + public class MarshallerMethods : System.IEquatable + { + public virtual Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods$() => throw null; +protected MarshallerMethods(Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods original) => throw null; + public MarshallerMethods() => throw null; + protected virtual System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public virtual bool Equals(Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods other) => throw null; + public override int GetHashCode() => throw null; + public Microsoft.CodeAnalysis.IMethodSymbol ManagedValuesDestination { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol ManagedValuesSource { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods left, Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods right) => throw null; + public static bool operator !=(Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods left, Microsoft.Interop.StatelessMarshallerShapeHelper.MarshallerMethods right) => throw null; + protected virtual bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public Microsoft.CodeAnalysis.IMethodSymbol ToManaged { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol ToManagedFinally { get => throw null; set { } } + public override string ToString() => throw null; + public Microsoft.CodeAnalysis.IMethodSymbol ToUnmanaged { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol ToUnmanagedWithBuffer { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol UnmanagedValuesDestination { get => throw null; set { } } + public Microsoft.CodeAnalysis.IMethodSymbol UnmanagedValuesSource { get => throw null; set { } } + } + } + public sealed class StaticPinnableManagedValueMarshaller : Microsoft.Interop.IMarshallingGenerator + { + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info) => throw null; + public StaticPinnableManagedValueMarshaller(Microsoft.Interop.IMarshallingGenerator innerMarshallingGenerator, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax getPinnableReferenceType) => throw null; + public System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info) => throw null; + public Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version) => throw null; + public bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context) => throw null; + public bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + } + public enum StringMarshalling + { + Custom = 0, + Utf8 = 1, + Utf16 = 2, + } + public abstract class StubCodeContext : System.IEquatable + { + public abstract Microsoft.Interop.StubCodeContext$(); +public abstract bool AdditionalTemporaryStateLivesAcrossStages { get; } + protected StubCodeContext(Microsoft.Interop.StubCodeContext original) => throw null; + protected StubCodeContext() => throw null; + public Microsoft.Interop.StubCodeContext.Stage CurrentStage { get => throw null; set { } } + public Microsoft.Interop.CustomTypeMarshallingDirection Direction { get => throw null; set { } } + protected virtual System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public virtual bool Equals(Microsoft.Interop.StubCodeContext other) => throw null; + public const string GeneratedNativeIdentifierSuffix = default; + public virtual string GetAdditionalIdentifier(Microsoft.Interop.TypePositionInfo info, string name) => throw null; + public override int GetHashCode() => throw null; + public virtual (string managed, string native) GetIdentifiers(Microsoft.Interop.TypePositionInfo info) => throw null; + public abstract (Microsoft.Interop.TargetFramework framework, System.Version version) GetTargetFramework(); + public static bool operator ==(Microsoft.Interop.StubCodeContext left, Microsoft.Interop.StubCodeContext right) => throw null; + public static bool operator !=(Microsoft.Interop.StubCodeContext left, Microsoft.Interop.StubCodeContext right) => throw null; + public Microsoft.Interop.StubCodeContext ParentContext { get => throw null; set { } } + protected virtual bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public abstract bool SingleFrameSpansNativeContext { get; } + public enum Stage + { + Invalid = 0, + Setup = 1, + Marshal = 2, + Pin = 3, + PinnedMarshal = 4, + Invoke = 5, + UnmarshalCapture = 6, + Unmarshal = 7, + NotifyForSuccessfulInvoke = 8, + Cleanup = 9, + GuaranteedUnmarshal = 10, + } + public override string ToString() => throw null; + } + public sealed class StubEnvironment : System.IEquatable + { + public Microsoft.Interop.StubEnvironment$() => throw null; +public static bool AreCompilationSettingsEqual(Microsoft.Interop.StubEnvironment env1, Microsoft.Interop.StubEnvironment env2) => throw null; + public Microsoft.CodeAnalysis.Compilation Compilation { get => throw null; set { } } + public StubEnvironment(Microsoft.CodeAnalysis.Compilation Compilation, Microsoft.Interop.TargetFramework TargetFramework, System.Version TargetFrameworkVersion, bool ModuleSkipLocalsInit) => throw null; + public void Deconstruct(out Microsoft.CodeAnalysis.Compilation Compilation, out Microsoft.Interop.TargetFramework TargetFramework, out System.Version TargetFrameworkVersion, out bool ModuleSkipLocalsInit) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.StubEnvironment other) => throw null; + public override int GetHashCode() => throw null; + public bool ModuleSkipLocalsInit { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.StubEnvironment left, Microsoft.Interop.StubEnvironment right) => throw null; + public static bool operator !=(Microsoft.Interop.StubEnvironment left, Microsoft.Interop.StubEnvironment right) => throw null; + public Microsoft.Interop.TargetFramework TargetFramework { get => throw null; set { } } + public System.Version TargetFrameworkVersion { get => throw null; set { } } + public override string ToString() => throw null; + } + public sealed class SyntaxEquivalentComparer : System.Collections.Generic.IEqualityComparer, System.Collections.Generic.IEqualityComparer + { + public bool Equals(Microsoft.CodeAnalysis.SyntaxNode x, Microsoft.CodeAnalysis.SyntaxNode y) => throw null; + public bool Equals(Microsoft.CodeAnalysis.SyntaxToken x, Microsoft.CodeAnalysis.SyntaxToken y) => throw null; + public int GetHashCode(Microsoft.CodeAnalysis.SyntaxNode obj) => throw null; + public int GetHashCode(Microsoft.CodeAnalysis.SyntaxToken obj) => throw null; + public static readonly Microsoft.Interop.SyntaxEquivalentComparer Instance; + } + public static partial class SyntaxExtensions + { + public static Microsoft.CodeAnalysis.SyntaxTokenList AddToModifiers(this Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.SyntaxKind modifierToAdd) => throw null; + public static Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax NestFixedStatements(this System.Collections.Immutable.ImmutableArray fixedStatements, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax innerStatement) => throw null; + public static Microsoft.CodeAnalysis.SyntaxTokenList StripTriviaFromTokens(this Microsoft.CodeAnalysis.SyntaxTokenList tokenList) => throw null; + } + public sealed class SzArrayType : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public SzArrayType(Microsoft.Interop.ManagedTypeInfo ElementTypeInfo) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out Microsoft.Interop.ManagedTypeInfo ElementTypeInfo) => throw null; + public Microsoft.Interop.ManagedTypeInfo ElementTypeInfo { get => throw null; set { } } + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public bool Equals(Microsoft.Interop.SzArrayType other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.SzArrayType left, Microsoft.Interop.SzArrayType right) => throw null; + public static bool operator !=(Microsoft.Interop.SzArrayType left, Microsoft.Interop.SzArrayType right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public enum TargetFramework + { + Unknown = 0, + Framework = 1, + Core = 2, + Standard = 3, + Net = 4, + } + public static class TypeNames + { + public const string AnsiStringMarshaller = default; + public const string BStrStringMarshaller = default; + public const string ContiguousCollectionMarshallerAttribute = default; + public const string CustomMarshallerAttribute = default; + public const string CustomMarshallerAttributeGenericPlaceholder = default; + public const string DefaultDllImportSearchPathsAttribute = default; + public const string DllImportAttribute = default; + public const string DllImportSearchPath = default; + public const string LCIDConversionAttribute = default; + public const string LibraryImportAttribute = default; + public static string MarshalEx(Microsoft.Interop.InteropGenerationOptions options) => throw null; + public const string MarshalUsingAttribute = default; + public const string NativeMarshallingAttribute = default; + public const string StringMarshalling = default; + public const string SuppressGCTransitionAttribute = default; + public const string System_Activator = default; + public const string System_CodeDom_Compiler_GeneratedCodeAttribute = default; + public const string System_IntPtr = default; + public const string System_ReadOnlySpan = default; + public const string System_ReadOnlySpan_Metadata = default; + public const string System_Runtime_CompilerServices_DisableRuntimeMarshallingAttribute = default; + public const string System_Runtime_CompilerServices_SkipLocalsInitAttribute = default; + public const string System_Runtime_CompilerServices_Unsafe = default; + public const string System_Runtime_InteropServices_ArrayMarshaller = default; + public const string System_Runtime_InteropServices_ArrayMarshaller_Metadata = default; + public const string System_Runtime_InteropServices_InAttribute = default; + public const string System_Runtime_InteropServices_Marshal = default; + public const string System_Runtime_InteropServices_MarshalAsAttribute = default; + public const string System_Runtime_InteropServices_MemoryMarshal = default; + public const string System_Runtime_InteropServices_OutAttribute = default; + public const string System_Runtime_InteropServices_PointerArrayMarshaller = default; + public const string System_Runtime_InteropServices_PointerArrayMarshaller_Metadata = default; + public const string System_Runtime_InteropServices_SafeHandle = default; + public const string System_Runtime_InteropServices_StructLayoutAttribute = default; + public const string System_Runtime_InteropServices_UnmanagedType = default; + public const string System_Span = default; + public const string System_Span_Metadata = default; + public const string System_Type = default; + public const string UnmanagedCallConvAttribute = default; + public const string Utf16StringMarshaller = default; + public const string Utf8StringMarshaller = default; + } + public sealed class TypeParameterTypeInfo : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public TypeParameterTypeInfo(string FullTypeName, string DiagnosticFormattedName) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public bool Equals(Microsoft.Interop.TypeParameterTypeInfo other) => throw null; + public override int GetHashCode() => throw null; + public static bool operator ==(Microsoft.Interop.TypeParameterTypeInfo left, Microsoft.Interop.TypeParameterTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.TypeParameterTypeInfo left, Microsoft.Interop.TypeParameterTypeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class TypePositionInfo : System.IEquatable + { + public Microsoft.Interop.TypePositionInfo$() => throw null; +public Microsoft.Interop.ByValueContentsMarshalKind ByValueContentsMarshalKind { get => throw null; set { } } + public static Microsoft.Interop.TypePositionInfo CreateForParameter(Microsoft.CodeAnalysis.IParameterSymbol paramSymbol, Microsoft.Interop.MarshallingInfo marshallingInfo, Microsoft.CodeAnalysis.Compilation compilation) => throw null; + public TypePositionInfo(Microsoft.Interop.ManagedTypeInfo ManagedType, Microsoft.Interop.MarshallingInfo MarshallingAttributeInfo) => throw null; + public void Deconstruct(out Microsoft.Interop.ManagedTypeInfo ManagedType, out Microsoft.Interop.MarshallingInfo MarshallingAttributeInfo) => throw null; + public override bool Equals(object obj) => throw null; + public bool Equals(Microsoft.Interop.TypePositionInfo other) => throw null; + public override int GetHashCode() => throw null; + public string InstanceIdentifier { get => throw null; set { } } + public bool IsByRef { get => throw null; } + public bool IsManagedReturnPosition { get => throw null; } + public bool IsNativeReturnPosition { get => throw null; } + public int ManagedIndex { get => throw null; set { } } + public Microsoft.Interop.ManagedTypeInfo ManagedType { get => throw null; set { } } + public Microsoft.Interop.MarshallingInfo MarshallingAttributeInfo { get => throw null; set { } } + public int NativeIndex { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.TypePositionInfo left, Microsoft.Interop.TypePositionInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.TypePositionInfo left, Microsoft.Interop.TypePositionInfo right) => throw null; + public Microsoft.CodeAnalysis.RefKind RefKind { get => throw null; set { } } + public Microsoft.CodeAnalysis.CSharp.SyntaxKind RefKindSyntax { get => throw null; set { } } + public const int ReturnIndex = -2147483647; + public override string ToString() => throw null; + public const int UnsetIndex = -2147483648; + } + public static partial class TypeSymbolExtensions + { + public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsTypeSyntax(this Microsoft.CodeAnalysis.ITypeSymbol type) => throw null; + public static (System.Collections.Immutable.ImmutableArray TypeArguments, System.Collections.Immutable.ImmutableArray TypeArgumentNullableAnnotations) GetAllTypeArgumentsIncludingInContainingTypes(this Microsoft.CodeAnalysis.INamedTypeSymbol genericType) => throw null; + public static bool IsAlwaysBlittable(this Microsoft.CodeAnalysis.SpecialType type) => throw null; + public static bool IsConsideredBlittable(this Microsoft.CodeAnalysis.ITypeSymbol type) => throw null; + public static bool IsConstructedFromEqualTypes(this Microsoft.CodeAnalysis.ITypeSymbol type, Microsoft.CodeAnalysis.ITypeSymbol other) => throw null; + public static bool IsIntegralType(this Microsoft.CodeAnalysis.SpecialType type) => throw null; + public static bool IsStrictlyBlittable(this Microsoft.CodeAnalysis.ITypeSymbol type) => throw null; + public static Microsoft.CodeAnalysis.INamedTypeSymbol ResolveUnboundConstructedTypeToConstructedType(this Microsoft.CodeAnalysis.INamedTypeSymbol unboundConstructedType, Microsoft.CodeAnalysis.INamedTypeSymbol instantiatedTemplateType, out int numOriginalTypeArgumentsSubstituted, out int extraTypeArgumentsInTemplate) => throw null; + } + public sealed class UnmanagedBlittableMarshallingInfo : Microsoft.Interop.MarshallingInfo, System.IEquatable + { + public override Microsoft.Interop.MarshallingInfo$() => throw null; +public UnmanagedBlittableMarshallingInfo(bool IsStrictlyBlittable) => throw null; + public void Deconstruct(out bool IsStrictlyBlittable) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.MarshallingInfo other) => throw null; + public bool Equals(Microsoft.Interop.UnmanagedBlittableMarshallingInfo other) => throw null; + public override int GetHashCode() => throw null; + public bool IsStrictlyBlittable { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.UnmanagedBlittableMarshallingInfo left, Microsoft.Interop.UnmanagedBlittableMarshallingInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.UnmanagedBlittableMarshallingInfo left, Microsoft.Interop.UnmanagedBlittableMarshallingInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public sealed class UnsupportedMarshallingFactory : Microsoft.Interop.IMarshallingGeneratorFactory + { + public Microsoft.Interop.IMarshallingGenerator Create(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public UnsupportedMarshallingFactory() => throw null; + } + public sealed class Utf16CharMarshaller : Microsoft.Interop.IMarshallingGenerator + { + public Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax AsNativeType(Microsoft.Interop.TypePositionInfo info) => throw null; + public Utf16CharMarshaller() => throw null; + public System.Collections.Generic.IEnumerable Generate(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public Microsoft.Interop.SignatureBehavior GetNativeSignatureBehavior(Microsoft.Interop.TypePositionInfo info) => throw null; + public Microsoft.Interop.ValueBoundaryBehavior GetValueBoundaryBehavior(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + public bool IsSupported(Microsoft.Interop.TargetFramework target, System.Version version) => throw null; + public bool SupportsByValueMarshalKind(Microsoft.Interop.ByValueContentsMarshalKind marshalKind, Microsoft.Interop.StubCodeContext context) => throw null; + public bool UsesNativeIdentifier(Microsoft.Interop.TypePositionInfo info, Microsoft.Interop.StubCodeContext context) => throw null; + } + public enum ValueBoundaryBehavior + { + ManagedIdentifier = 0, + NativeIdentifier = 1, + AddressOfNativeIdentifier = 2, + CastNativeIdentifier = 3, + } + public sealed class ValueTypeInfo : Microsoft.Interop.ManagedTypeInfo, System.IEquatable + { + public override Microsoft.Interop.ManagedTypeInfo$() => throw null; +public ValueTypeInfo(string FullTypeName, string DiagnosticFormattedName, bool IsByRefLike) : base(default(Microsoft.Interop.ManagedTypeInfo)) => throw null; + public void Deconstruct(out string FullTypeName, out string DiagnosticFormattedName, out bool IsByRefLike) => throw null; + protected override System.Type EqualityContract { get => throw null; } + public override bool Equals(object obj) => throw null; + public override sealed bool Equals(Microsoft.Interop.ManagedTypeInfo other) => throw null; + public bool Equals(Microsoft.Interop.ValueTypeInfo other) => throw null; + public override int GetHashCode() => throw null; + public bool IsByRefLike { get => throw null; set { } } + public static bool operator ==(Microsoft.Interop.ValueTypeInfo left, Microsoft.Interop.ValueTypeInfo right) => throw null; + public static bool operator !=(Microsoft.Interop.ValueTypeInfo left, Microsoft.Interop.ValueTypeInfo right) => throw null; + protected override bool PrintMembers(System.Text.StringBuilder builder) => throw null; + public override string ToString() => throw null; + } + public struct VariableDeclarations + { + public static Microsoft.Interop.VariableDeclarations GenerateDeclarationsForManagedToNative(Microsoft.Interop.BoundGenerators marshallers, Microsoft.Interop.StubCodeContext context, bool initializeDeclarations) => throw null; + public System.Collections.Immutable.ImmutableArray Initializations { get => throw null; set { } } + public System.Collections.Immutable.ImmutableArray Variables { get => throw null; set { } } + } + public sealed class VariantBoolMarshaller : Microsoft.Interop.BoolMarshallerBase + { + public VariantBoolMarshaller() : base(default(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax), default(int), default(int), default(bool)) => throw null; + } + public sealed class WinBoolMarshaller : Microsoft.Interop.BoolMarshallerBase + { + public WinBoolMarshaller(bool signed) : base(default(Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax), default(int), default(int), default(bool)) => throw null; + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/System.Text.Json.SourceGeneration.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/System.Text.Json.SourceGeneration.cs new file mode 100644 index 00000000000..7412307e1a3 --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/System.Text.Json.SourceGeneration.cs @@ -0,0 +1,20 @@ +// This file contains auto-generated code. +// Generated from `System.Text.Json.SourceGeneration, Version=7.0.8.36312, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51`. +namespace System +{ + namespace Text + { + namespace Json + { + namespace SourceGeneration + { + public sealed class JsonSourceGenerator : Microsoft.CodeAnalysis.IIncrementalGenerator + { + public JsonSourceGenerator() => throw null; + public System.Collections.Generic.Dictionary GetSerializableTypes() => throw null; + public void Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) => throw null; + } + } + } + } +} diff --git a/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/System.Text.RegularExpressions.Generator.cs b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/System.Text.RegularExpressions.Generator.cs new file mode 100644 index 00000000000..64913f80114 --- /dev/null +++ b/csharp/ql/test/resources/stubs/_frameworks/Microsoft.NETCore.App/System.Text.RegularExpressions.Generator.cs @@ -0,0 +1,32 @@ +// This file contains auto-generated code. +// Generated from `System.Text.RegularExpressions.Generator, Version=7.0.8.36312, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a`. +namespace System +{ + namespace Text + { + namespace RegularExpressions + { + namespace Generator + { + public class RegexGenerator : Microsoft.CodeAnalysis.IIncrementalGenerator + { + public RegexGenerator() => throw null; + public void Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext context) => throw null; + } + public sealed class UpgradeToGeneratedRegexAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer + { + public UpgradeToGeneratedRegexAnalyzer() => throw null; + public override void Initialize(Microsoft.CodeAnalysis.Diagnostics.AnalysisContext context) => throw null; + public override System.Collections.Immutable.ImmutableArray SupportedDiagnostics { get => throw null; } + } + public sealed class UpgradeToGeneratedRegexCodeFixer : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider + { + public UpgradeToGeneratedRegexCodeFixer() => throw null; + public override System.Collections.Immutable.ImmutableArray FixableDiagnosticIds { get => throw null; } + public override Microsoft.CodeAnalysis.CodeFixes.FixAllProvider GetFixAllProvider() => throw null; + public override System.Threading.Tasks.Task RegisterCodeFixesAsync(Microsoft.CodeAnalysis.CodeFixes.CodeFixContext context) => throw null; + } + } + } + } +}